Fix unix build

lhecker · lhecker · commit 08690f060e77 · 2026-02-10T18:23:31.000+01:00
diff --git a/crates/edit/src/sys/unix.rs b/crates/edit/src/sys/unix.rs
@@ -15,7 +15,8 @@ use std::ptr::{NonNull, null_mut};
 use std::{io, thread, time};
 
 use stdext::arena::{Arena, scratch_arena};
-use stdext::{arena_format, collections};
+use stdext::arena_format;
+use stdext::collections::{BString, BVec};
 
 use crate::helpers::*;
 
@@ -182,11 +183,11 @@ pub fn read_stdin(arena: &Arena, mut timeout: time::Duration) -> Option<BString<
         // later turn it into UTF8 using `from_utf8_lossy_owned`.
         // It is important that we allocate the buffer with an explicit capacity,
         // because we later use `spare_capacity_mut` to access it.
-        buf.reserve(4 * KIBI);
+        buf.reserve(arena, 4 * KIBI);
 
         // We got some leftover broken UTF8 from a previous read? Prepend it.
         if STATE.utf8_len != 0 {
-            buf.extend_from_slice(&STATE.utf8_buf[..STATE.utf8_len]);
+            buf.extend_from_slice(arena, &STATE.utf8_buf[..STATE.utf8_len]);
             STATE.utf8_len = 0;
         }
 
@@ -271,7 +272,7 @@ pub fn read_stdin(arena: &Arena, mut timeout: time::Duration) -> Option<BString<
             }
         }
 
-        let mut result = BString::from_utf8_lossy_owned(buf);
+        let mut result = BString::from_utf8_lossy(arena, buf);
 
         // We received a SIGWINCH? Add a fake window size sequence for our input parser.
         // I prepend it so that on startup, the TUI system gets first initialized with a size.
@@ -280,12 +281,11 @@ pub fn read_stdin(arena: &Arena, mut timeout: time::Duration) -> Option<BString<
             let (w, h) = get_window_size();
             if w > 0 && h > 0 {
                 let scratch = scratch_arena(Some(arena));
-                let seq = arena_format!(&scratch, "\x1b[8;{h};{w}t");
-                result.replace_range(0..0, &seq);
+                let seq = arena_format!(&*scratch, "\x1b[8;{h};{w}t");
+                result.replace_range(arena, 0..0, &seq);
             }
         }
 
-        result.shrink_to_fit();
         Some(result)
     }
 }
@@ -435,7 +435,7 @@ pub fn icu_detect_renaming_suffix(arena: &Arena, handle: NonNull<c_void>) -> BSt
     unsafe {
         type T = *const c_void;
 
-        let mut res = BString::new_in(arena);
+        let mut res = BString::empty();
 
         // Check if the ICU library is using unversioned symbols.
         // Return an empty suffix in that case.
@@ -481,8 +481,8 @@ pub fn icu_detect_renaming_suffix(arena: &Arena, handle: NonNull<c_void>) -> BSt
         let version_end = version.find('.').unwrap_or(version.len());
         let version = &version[..version_end];
 
-        res.push('_');
-        res.push_str(version);
+        res.push(arena, '_');
+        res.push_str(arena, version);
         res
     }
 }
@@ -506,29 +506,35 @@ where
         let name = unsafe { std::ffi::CStr::from_ptr(name) };
         let name = unsafe { name.to_str().unwrap_unchecked() };
 
-        let mut res = ManuallyDrop::new(BString::new_in(arena));
-        res.reserve(name.len() + suffix.len() + 1);
-        res.push_str(name);
-        res.push_str(suffix);
-        res.push('\0');
+        let mut res = BString::empty();
+        res.reserve(arena, name.len() + suffix.len() + 1);
+        res.push_str(arena, name);
+        res.push_str(arena, suffix);
+        res.push(arena, '\0');
         res.as_ptr() as *const c_char
     }
 }
 
-pub fn preferred_languages(arena: &Arena) -> Vec<BString<'_>, &Arena> {
+pub fn preferred_languages(arena: &Arena) -> BVec<'_, BString<'_>> {
     let mut locales = BVec::empty();
 
     for key in ["LANGUAGE", "LC_ALL", "LANG"] {
         if let Ok(val) = std::env::var(key)
             && !val.is_empty()
         {
-            locales.extend(val.split(':').filter(|s| !s.is_empty()).map(|s| {
-                // Replace all underscores with dashes,
-                // because the localization code expects pt-br, not pt_BR.
-                let mut res = BVec::empty();
-                res.extend(s.as_bytes().iter().map(|&b| if b == b'_' { b'-' } else { b }));
-                unsafe { BString::from_utf8_unchecked(res) }
-            }));
+            locales.extend_sloppy(
+                arena,
+                val.split(':').filter(|s| !s.is_empty()).map(|s| {
+                    // Replace all underscores with dashes,
+                    // because the localization code expects pt-br, not pt_BR.
+                    let mut res = BVec::empty();
+                    res.extend(
+                        arena,
+                        s.as_bytes().iter().map(|&b| if b == b'_' { b'-' } else { b }),
+                    );
+                    unsafe { BString::from_utf8_unchecked(res) }
+                }),
+            );
             break;
         }
     }
diff --git a/crates/stdext/src/collections/string.rs b/crates/stdext/src/collections/string.rs
@@ -1,9 +1,10 @@
 use std::fmt::{self};
-use std::ops::{Deref, DerefMut};
+use std::ops::{Bound, Deref, DerefMut, RangeBounds};
 use std::slice;
 use std::str::Utf8Error;
 
 use crate::alloc::Allocator;
+use crate::cold_path;
 use crate::collections::BVec;
 
 /// Like a `String` but on borrowed memory. Built on top of [`BVec<u8>`].
@@ -34,6 +35,38 @@ impl<'a> BString<'a> {
         Ok(Self { vec })
     }
 
+    /// Validates UTF-8, replacing invalid sequences with U+FFFD.
+    pub fn from_utf8_lossy(alloc: &'a dyn Allocator, vec: BVec<'a, u8>) -> Self {
+        let mut iter = vec.utf8_chunks();
+
+        if let Some(mut chunk) = iter.next()
+            && !chunk.invalid().is_empty()
+        {
+            // We only need to create a copy if the input is non-empty
+            // and contains at least some invalid UTF-8.
+            cold_path();
+
+            let mut res = Self::empty();
+            res.reserve(alloc, vec.len());
+
+            loop {
+                res.push_str(alloc, chunk.valid());
+                if !chunk.invalid().is_empty() {
+                    res.push_str(alloc, "\u{FFFD}");
+                }
+                chunk = match iter.next() {
+                    Some(chunk) => chunk,
+                    None => break,
+                };
+            }
+
+            res
+        } else {
+            // Otherwise, we can just return the `vec` as-is.
+            Self { vec }
+        }
+    }
+
     /// Wraps a byte vec as UTF-8 without validating it.
     ///
     /// # Safety
@@ -206,6 +239,26 @@ impl<'a> BString<'a> {
         iterator.for_each(move |c| self.push(alloc, c));
     }
 
+    /// Replaces a range of characters with a new string.
+    pub fn replace_range<R: RangeBounds<usize>>(
+        &mut self,
+        alloc: &'a dyn Allocator,
+        range: R,
+        replace_with: &str,
+    ) {
+        match range.start_bound() {
+            Bound::Included(&n) => assert!(self.is_char_boundary(n)),
+            Bound::Excluded(&n) => assert!(self.is_char_boundary(n + 1)),
+            Bound::Unbounded => {}
+        };
+        match range.end_bound() {
+            Bound::Included(&n) => assert!(self.is_char_boundary(n + 1)),
+            Bound::Excluded(&n) => assert!(self.is_char_boundary(n)),
+            Bound::Unbounded => {}
+        };
+        unsafe { self.as_mut_vec() }.replace_range(alloc, range, replace_with.as_bytes());
+    }
+
     /// Finds `old` in the string and replaces it with `new`.
     /// Only performs one replacement.
     pub fn replace_once_in_place(&mut self, alloc: &'a dyn Allocator, old: &str, new: &str) {
diff --git a/crates/stdext/src/collections/vec.rs b/crates/stdext/src/collections/vec.rs
@@ -43,6 +43,18 @@ impl<'a, T> BVec<'a, T> {
         }
     }
 
+    pub fn from_slice(slice: &'a mut [T]) -> Self {
+        let slice = NonNull::from_mut(slice);
+        Self {
+            ptr: slice.cast(),
+            len: slice.len(),
+            cap: slice.len(),
+            _marker: PhantomData,
+            #[cfg(debug_assertions)]
+            alloc: None,
+        }
+    }
+
     /// Leaks a `Vec` and turns it into a "borrowed" `BVec`.
     pub fn from_std_vec(vec: Vec<T>) -> Self {
         let (ptr, len, cap) = vec.into_raw_parts();
@@ -112,6 +124,19 @@ impl<'a, T> BVec<'a, T> {
         self.len = new_len;
     }
 
+    /// Shortens the vector.
+    pub fn truncate(&mut self, len: usize) {
+        unsafe {
+            // NOTE: It's intentional that this doesn't avoid drops when `len == self.len`,
+            // because that would introduce a branch for the common case of `truncate(0)`.
+            if let Some(r) = self.len.checked_sub(len) {
+                let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), r);
+                self.len = len;
+                ptr::drop_in_place(s);
+            }
+        }
+    }
+
     /// Raw pointer to the backing buffer.
     #[inline]
     pub fn as_ptr(&self) -> *const T {
