build(deps): bump unicode-width from =0.1.12 to 0.2.2

Author: RoloEdits

Cargo.lock

@@ -57,6 +57,7 @@ sonic-rs = "0.5"
 globset = "0.4"
 etcetera = "0.11"
 arc-swap = "1.9"
+memchr = "2"
 
 [workspace.package]
 version = "25.7.1"

Cargo.toml

@@ -24,12 +24,7 @@ ropey.workspace = true
 smallvec = "1.15"
 smartstring = "1.0.1"
 unicode-segmentation.workspace = true
-# unicode-width is changing width definitions
-# that both break our logic and disagree with common
-# width definitions in terminals, we need to replace it.
-# For now lets lock the version to avoid rendering glitches
-# when installing without `--locked`
-unicode-width = "=0.1.12"
+unicode-width = "0.2.2"
 unicode-general-category = "1.1"
 slotmap.workspace = true
 tree-house.workspace = true
@@ -58,6 +53,8 @@ parking_lot.workspace = true
 globset.workspace = true
 regex-cursor = "0.1.5"
 
+memchr.workspace = true
+
 [dev-dependencies]
 quickcheck = { version = "1", default-features = false }
 indoc = "2.0.6"

helix-core/Cargo.toml

@@ -3,7 +3,6 @@
 //! Based on <https://github.com/cessen/led/blob/c4fa72405f510b7fd16052f90a598c429b3104a6/src/graphemes.rs>
 use ropey::{str_utils::byte_to_char_idx, RopeSlice};
 use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};
-use unicode_width::UnicodeWidthStr;
 
 use std::borrow::Cow;
 use std::fmt::{self, Debug, Display};
@@ -13,7 +12,7 @@ use std::ptr::NonNull;
 use std::{slice, str};
 
 use crate::chars::{char_is_whitespace, char_is_word};
-use crate::LineEnding;
+use crate::{unicode, LineEnding};
 
 #[inline]
 pub fn tab_width_at(visual_x: usize, tab_width: u16) -> usize {
@@ -93,29 +92,30 @@ impl Display for Grapheme<'_> {
     }
 }
 
+/// Returns the width of the grapheme.
+///
+/// # Invariant
+///
+/// This function should only be passed a single grapheme.
+#[inline]
 #[must_use]
 pub fn grapheme_width(g: &str) -> usize {
+    // ASCII fast-path.
     if g.as_bytes()[0] <= 127 {
-        // Fast-path ascii.
-        // Point 1: theoretically, ascii control characters should have zero
-        // width, but in our case we actually want them to have width: if they
-        // show up in text, we want to treat them as textual elements that can
-        // be edited.  So we can get away with making all ascii single width
-        // here.
-        // Point 2: we're only examining the first codepoint here, which means
-        // we're ignoring graphemes formed with combining characters.  However,
-        // if it starts with ascii, it's going to be a single-width grapeheme
-        // regardless, so, again, we can get away with that here.
-        // Point 3: we're only examining the first _byte_.  But for utf8, when
-        // checking for ascii range values only, that works.
+        // We're only examining the first _byte_. But for UTF-8, when checking
+        // for ASCII range values only, that works, but which means we're ignoring
+        // graphemes formed with combining characters. However, if it starts with
+        // ASCII, it's going to be a single-width grapheme regardless, so, again,
+        // we can get away with that here.
+        //
+        // Theoretically, ASCII control characters should have zero width, but
+        // in our case we actually want them to have width: if they show up in
+        // text, we want to treat them as textual elements that can be edited.
         1
     } else {
-        // We use max(1) here because all grapeheme clusters--even illformed
-        // ones--should have at least some width so they can be edited
-        // properly.
-        // TODO properly handle unicode width for all codepoints
-        // example of where unicode width is currently wrong: 🤦🏼‍♂️ (taken from https://hsivonen.fi/string-length/)
-        UnicodeWidthStr::width(g).max(1)
+        // We use `.max(1)` here, because all grapheme clusters -- even ill-formed
+        // ones -- should have at least some width, so they can be edited properly.
+        unicode::width(g).max(1)
     }
 }
 

helix-core/src/graphemes.rs

@@ -38,6 +38,64 @@ pub mod unicode {
     pub use unicode_general_category as category;
     pub use unicode_segmentation as segmentation;
     pub use unicode_width as width;
+    use unicode_width::UnicodeWidthStr;
+
+    #[inline]
+    #[must_use]
+    pub fn width(s: &str) -> usize {
+        if s.is_empty() {
+            return 0;
+        }
+
+        let mut width = s.width();
+        let chars = s.as_bytes();
+        // `UnicodeWidthStr::width` assigns a width of 1 to certain control
+        // sequences at the *string* level.
+        //
+        // Notably, the CRLF sequence (`"\r\n"`) is treated as a single unit
+        // and has a total width of 1, even though `'\r'` and `'\n'` each
+        // have a character width of 1 when considered individually.
+        //
+        // This function needs newline and tab characters to contribute zero
+        // width. We correct for this by subtracting the count of `'\n'` and
+        // `'\t'` characters from the string width.
+        //
+        // NOTE: Subtracting on `\n` works for `\r\n`, as this grapheme only
+        // counts as 1 width, so just subtracting 1 for the `\n` would zero
+        // it out, removing its contribution to the width.
+        for _ in memchr::memchr2_iter(b'\n', b'\t', chars) {
+            if width == 0 {
+                break;
+            }
+
+            width -= 1;
+        }
+        width
+    }
+
+    #[cfg(test)]
+    mod test {
+        use super::width;
+
+        #[test]
+        fn should_have_expected_unicode_width() {
+            assert_eq!(width("\n"), 0);
+            assert_eq!(width("\t"), 0);
+            assert_eq!(width("\r\n"), 0);
+            assert_eq!(width("\r\n\t"), 0);
+            assert_eq!(width("\n\t\r\n"), 0);
+            assert_eq!(width("\n\tH\r\n"), 1);
+            assert_eq!(width("🤦🏼‍♂️"), 2);
+            assert_eq!(width("\n🤦🏼‍♂️\n"), 2);
+            assert_eq!(width("\r\n🤦🏼‍♂️\r\n"), 2);
+            assert_eq!(width("\t🤦🏼‍♂️\t"), 2);
+            assert_eq!(width("\n\t🤦🏼‍♂️\t\n"), 2);
+            assert_eq!(width("\u{200B}"), 0);
+            assert_eq!(width("▲"), 1);
+            assert_eq!(width(" ▲ "), 3);
+            assert_eq!(width("┌"), 1);
+        }
+    }
 }
 
 pub use helix_loader::find_workspace;

helix-core/src/lib.rs

@@ -1397,17 +1397,15 @@ fn compute_inlay_hints_for_view(
                 // Truncate the hint if too long
                 if let Some(limit) = inlay_hints_length_limit {
                     // Limit on displayed width
-                    use helix_core::unicode::{
-                        segmentation::UnicodeSegmentation, width::UnicodeWidthStr,
-                    };
+                    use helix_core::unicode::{self, segmentation::UnicodeSegmentation};
 
-                    let width = label.width();
+                    let width = unicode::width(&label);
                     let limit = limit.get().into();
                     if width > limit {
                         let mut floor_boundary = 0;
                         let mut acc = 0;
                         for (i, grapheme_cluster) in label.grapheme_indices(true) {
-                            acc += grapheme_cluster.width();
+                            acc += unicode::width(grapheme_cluster);
 
                             if acc > limit {
                                 floor_boundary = i;

helix-term/src/commands/lsp.rs

@@ -19,8 +19,7 @@ use helix_core::{
     movement::Direction,
     syntax::{self, OverlayHighlights},
     text_annotations::TextAnnotations,
-    unicode::width::UnicodeWidthStr,
-    visual_offset_from_block, Change, Position, Range, Selection, Transaction,
+    unicode, visual_offset_from_block, Change, Position, Range, Selection, Transaction,
 };
 use helix_view::{
     annotations::diagnostics::DiagnosticFilter,
@@ -1639,7 +1638,7 @@ impl Component for EditorView {
 
         // render status msg
         if let Some((status_msg, severity)) = &cx.editor.status_msg {
-            status_msg_width = status_msg.width();
+            status_msg_width = unicode::width(status_msg);
             use helix_view::editor::Severity;
             let style = if *severity == Severity::Error {
                 cx.editor.theme.get("error")

helix-term/src/ui/editor.rs

@@ -1,7 +1,7 @@
 use crate::compositor::{Component, Compositor, Context, Event, EventResult};
 use crate::{alt, ctrl, key, shift, ui};
 use arc_swap::ArcSwap;
-use helix_core::syntax;
+use helix_core::{syntax, unicode};
 use helix_view::document::Mode;
 use helix_view::input::KeyEvent;
 use helix_view::keyboard::KeyCode;
@@ -13,7 +13,6 @@ use tui::widgets::{Block, Widget};
 
 use helix_core::{
     unicode::segmentation::{GraphemeCursor, UnicodeSegmentation},
-    unicode::width::UnicodeWidthStr,
     Position,
 };
 use helix_view::{
@@ -544,7 +543,7 @@ impl Prompt {
         } else {
             let line_width = self.line_area.width as usize;
 
-            if self.line.width() < line_width {
+            if unicode::width(&self.line) < line_width {
                 self.anchor = 0;
             } else if self.cursor <= self.anchor {
                 // Ensure the grapheme under the cursor is in view.
@@ -553,14 +552,14 @@ impl Prompt {
                     .next_back()
                     .map(|(i, _)| i)
                     .unwrap_or_default();
-            } else if self.line[self.anchor..self.cursor].width() > line_width {
+            } else if unicode::width(&self.line[self.anchor..self.cursor]) > line_width {
                 // Set the anchor to the last grapheme cluster before the width is exceeded.
                 let mut width = 0;
                 self.anchor = self.line[..self.cursor]
                     .grapheme_indices(true)
                     .rev()
                     .find_map(|(idx, g)| {
-                        width += g.width();
+                        width += unicode::width(g);
                         if width > line_width {
                             Some(idx + g.len())
                         } else {
@@ -571,16 +570,18 @@ impl Prompt {
             }
 
             self.truncate_start = self.anchor > 0;
-            self.truncate_end = self.line[self.anchor..].width() > line_width;
+            self.truncate_end = unicode::width(&self.line[self.anchor..]) > line_width;
 
             // if we keep inserting characters just before the end elipsis, we move the anchor
             // so that those new characters are displayed
-            if self.truncate_end && self.line[self.anchor..self.cursor].width() >= line_width {
+            if self.truncate_end
+                && unicode::width(&self.line[self.anchor..self.cursor]) >= line_width
+            {
                 // Move the anchor forward by one non-zero-width grapheme.
                 self.anchor += self.line[self.anchor..]
                     .grapheme_indices(true)
                     .find_map(|(idx, g)| {
-                        if g.width() > 0 {
+                        if unicode::width(g) > 0 {
                             Some(idx + g.len())
                         } else {
                             None
@@ -771,11 +772,11 @@ impl Component for Prompt {
             .clip_left(self.prompt.len() as u16)
             .clip_right(if self.prompt.is_empty() { 2 } else { 0 });
 
-        let mut col = area.left() as usize + self.line[self.anchor..self.cursor].width();
+        let mut col = area.left() as usize + unicode::width(&self.line[self.anchor..self.cursor]);
 
         // ensure the cursor does not go beyond elipses
         if self.truncate_end
-            && self.line[self.anchor..self.cursor].width() >= self.line_area.width as usize
+            && unicode::width(&self.line[self.anchor..self.cursor]) >= self.line_area.width as usize
         {
             col -= 1;
         }
@@ -784,7 +785,7 @@ impl Component for Prompt {
             col += self.line[self.cursor..]
                 .graphemes(true)
                 .next()
-                .map_or(0, |g| g.width());
+                .map_or(0, unicode::width);
         }
 
         let line = area.height as usize - 1;

helix-term/src/ui/prompt.rs

@@ -1,5 +1,5 @@
 use helix_core::indent::IndentStyle;
-use helix_core::{coords_at_pos, encoding, unicode::width::UnicodeWidthStr, Position};
+use helix_core::{coords_at_pos, encoding, unicode, Position};
 use helix_lsp::lsp::DiagnosticSeverity;
 use helix_view::document::DEFAULT_LANGUAGE_NAME;
 use helix_view::{
@@ -176,7 +176,7 @@ where
         format!(" {mode_str} ")
     } else {
         // If not focused, explicitly leave an empty space instead of returning None.
-        " ".repeat(mode_str.width() + 2)
+        " ".repeat(unicode::width(mode_str) + 2)
     };
     let style = if visible && config.color_modes {
         match context.editor.mode() {

helix-term/src/ui/statusline.rs

@@ -3,7 +3,7 @@ use crate::{
     buffer::{Buffer, Cell},
     terminal::Config,
 };
-use helix_core::unicode::width::UnicodeWidthStr;
+use helix_core::unicode;
 use helix_view::graphics::{CursorKind, Rect};
 use std::{fmt::Write, io};
 
@@ -30,7 +30,7 @@ fn buffer_view(buffer: &Buffer) -> String {
             } else {
                 overwritten.push((x, &c.symbol))
             }
-            skip = std::cmp::max(skip, c.symbol.width()).saturating_sub(1);
+            skip = std::cmp::max(skip, unicode::width(&c.symbol)).saturating_sub(1);
         }
         view.push('"');
         if !overwritten.is_empty() {