Merge commit 'baa3cb05b4738c0fe2275d11b2eb2be3cfe7fc40' into dev/lhecker/syntax-highlighting

Author: lhecker

.cargo/release-nightly.toml

@@ -13,4 +13,3 @@ rustflags = [
 [unstable]
 panic-immediate-abort = true
 build-std = ["std", "panic_abort"]
-build-std-features = ["default", "optimize_for_size"]

Cargo.toml

@@ -7,7 +7,7 @@ resolver = "2"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/microsoft/edit"
-rust-version = "1.92"
+rust-version = "1.93"
 
 # We use `opt-level = "s"` as it significantly reduces binary size.
 # We could then use the `#[optimize(speed)]` attribute for spot optimizations.

crates/edit/benches/lib.rs

@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-#![feature(allocator_api)]
-
 use std::hint::black_box;
 use std::io::Cursor;
 use std::ops::Range;
@@ -12,20 +10,22 @@ use std::{mem, vec};
 use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use edit::helpers::*;
 use edit::simd::MemsetSafe;
-use edit::{buffer, hash, json, lsh, oklab, simd, unicode};
-use stdext::arena::{Arena, scratch_arena};
+use edit::{buffer, glob, hash, json, lsh, oklab, simd, unicode};
+use stdext::arena::{self, Arena, scratch_arena};
+use stdext::collections::BVec;
+use stdext::unicode::Utf8Chars;
 use stdext::{arena, glob, varint};
 
 struct EditingTracePatch<'a>(usize, usize, &'a str);
 
 struct EditingTraceTransaction<'a> {
-    patches: Vec<EditingTracePatch<'a>, &'a Arena>,
+    patches: BVec<'a, EditingTracePatch<'a>>,
 }
 
 struct EditingTraceData<'a> {
     start_content: &'a str,
     end_content: &'a str,
-    txns: Vec<EditingTraceTransaction<'a>, &'a Arena>,
+    txns: BVec<'a, EditingTraceTransaction<'a>>,
 }
 
 fn bench_buffer(c: &mut Criterion) {
@@ -42,24 +42,25 @@ fn bench_buffer(c: &mut Criterion) {
         let mut res = EditingTraceData {
             start_content: root.get_str("startContent").unwrap(),
             end_content: root.get_str("endContent").unwrap(),
-            txns: Vec::with_capacity_in(txns.len(), &scratch),
+            txns: BVec::empty(),
         };
+        res.txns.reserve(&*scratch, txns.len());
 
         for txn in txns {
             let txn = txn.as_object().unwrap();
             let patches = txn.get_array("patches").unwrap();
-            let mut txn =
-                EditingTraceTransaction { patches: Vec::with_capacity_in(patches.len(), &scratch) };
+            let mut txn = EditingTraceTransaction { patches: BVec::empty() };
+            txn.patches.reserve(&*scratch, patches.len());
 
             for patch in patches {
                 let patch = patch.as_array().unwrap();
                 let offset = patch[0].as_number().unwrap() as usize;
                 let del_len = patch[1].as_number().unwrap() as usize;
                 let ins_str = patch[2].as_str().unwrap();
-                txn.patches.push(EditingTracePatch(offset, del_len, ins_str));
+                txn.patches.push(&*scratch, EditingTracePatch(offset, del_len, ins_str));
             }
 
-            res.txns.push(txn);
+            res.txns.push(&*scratch, txn);
         }
 
         res
@@ -257,7 +258,7 @@ fn bench_simd_memchr2(c: &mut Criterion) {
     }
 }
 
-fn bench_simd_memset<T: MemsetSafe + Copy + Default>(c: &mut Criterion) {
+fn bench_simd_memset<T: Copy + Default>(c: &mut Criterion) {
     let mut group = c.benchmark_group("simd");
     let name = format!("memset<{}>", std::any::type_name::<T>());
     let size = mem::size_of::<T>();
@@ -272,7 +273,7 @@ fn bench_simd_memset<T: MemsetSafe + Copy + Default>(c: &mut Criterion) {
             &bytes,
             |b, &bytes| {
                 let slice = unsafe { buf.get_unchecked_mut(..bytes / size) };
-                b.iter(|| simd::memset(black_box(slice), Default::default()));
+                b.iter(|| stdext::simd::memset(black_box(slice), Default::default()));
             },
         );
     }
@@ -304,9 +305,7 @@ fn bench_unicode(c: &mut Criterion) {
     c.benchmark_group("unicode::Utf8Chars")
         .throughput(Throughput::Bytes(bytes.len() as u64))
         .bench_function("next", |b| {
-            b.iter(|| {
-                unicode::Utf8Chars::new(bytes, 0).fold(0u32, |acc, ch| acc.wrapping_add(ch as u32))
-            })
+            b.iter(|| Utf8Chars::new(bytes, 0).fold(0u32, |acc, ch| acc.wrapping_add(ch as u32)))
         });
 }
 

crates/edit/src/base64.rs

@@ -3,7 +3,8 @@
 
 //! Base64 facilities.
 
-use stdext::arena::ArenaString;
+use stdext::arena::Arena;
+use stdext::collections::BString;
 
 const CHARSET: [u8; 64] = *b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
@@ -15,15 +16,15 @@ pub fn encode_len(src_len: usize) -> usize {
 }
 
 /// Encodes the given bytes as base64 and appends them to the destination string.
-pub fn encode(dst: &mut ArenaString, src: &[u8]) {
+pub fn encode<'a>(arena: &'a Arena, dst: &mut BString<'a>, src: &[u8]) {
     unsafe {
         let mut inp = src.as_ptr();
         let mut remaining = src.len();
         let dst = dst.as_mut_vec();
 
         let out_len = encode_len(src.len());
         // ... we can then use this fact to reserve space all at once.
-        dst.reserve(out_len);
+        dst.reserve(arena, out_len);
 
         // SAFETY: Getting a pointer to the reserved space is only safe
         // *after* calling `reserve()` as it may change the pointer.
@@ -79,16 +80,17 @@ pub fn encode(dst: &mut ArenaString, src: &[u8]) {
 
 #[cfg(test)]
 mod tests {
-    use stdext::arena::{Arena, ArenaString};
+    use stdext::arena::scratch_arena;
+    use stdext::collections::BString;
 
     use super::encode;
 
     #[test]
     fn test_basic() {
-        let arena = Arena::new(4 * 1024).unwrap();
+        let scratch = scratch_arena(None);
         let enc = |s: &[u8]| {
-            let mut dst = ArenaString::new_in(&arena);
-            encode(&mut dst, s);
+            let mut dst = BString::empty();
+            encode(&scratch, &mut dst, s);
             dst
         };
         assert_eq!(enc(b""), "");

crates/edit/src/bin/edit/documents.rs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use std::collections::LinkedList;
 use std::ffi::OsStr;
 use std::fs::File;
 use std::path::{Path, PathBuf};
@@ -110,7 +109,7 @@ impl Document {
 
 #[derive(Default)]
 pub struct DocumentManager {
-    list: LinkedList<Document>,
+    list: Vec<Document>,
 }
 
 impl DocumentManager {
@@ -121,30 +120,48 @@ impl DocumentManager {
 
     #[inline]
     pub fn active(&self) -> Option<&Document> {
-        self.list.front()
+        self.list.last()
     }
 
     #[inline]
     pub fn active_mut(&mut self) -> Option<&mut Document> {
-        self.list.front_mut()
+        self.list.last_mut()
     }
 
-    #[inline]
     pub fn update_active<F: FnMut(&Document) -> bool>(&mut self, mut func: F) -> bool {
-        let mut cursor = self.list.cursor_front_mut();
-        while let Some(doc) = cursor.current() {
-            if func(doc) {
-                let list = cursor.remove_current_as_list().unwrap();
-                self.list.cursor_front_mut().splice_before(list);
-                return true;
-            }
-            cursor.move_next();
+        let Some(idx) = self.list.iter().rposition(&mut func) else {
+            return false;
+        };
+
+        // Already active (= last) document matched? Nothing to do.
+        if idx == self.list.len() - 1 {
+            return false;
         }
-        false
+
+        // Otherwise, move the matched document to the end of the list so it becomes active.
+        // Uses unsafe, because `rotate_left()` is horrendously bad with -Copt-level=s
+        // (it's really almost comical) and I just don't tolerate that.
+        // If I'm dead and you're looking to rewrite this use `list.push(list.remove(idx))`.
+        unsafe {
+            let beg = self.list.as_mut_ptr();
+            let doc = beg.add(idx);
+            let last = beg.add(self.list.len() - 1);
+            let amount = self.list.len() - idx - 1;
+            let mut temp = std::mem::MaybeUninit::<Document>::uninit();
+
+            // Make a backup of the document
+            std::ptr::copy_nonoverlapping(doc, temp.as_mut_ptr(), 1);
+            // Shift the rest to the front
+            std::ptr::copy(doc.add(1), doc, amount);
+            // Move the backup to the end
+            std::ptr::copy_nonoverlapping(temp.as_ptr(), last, 1);
+        }
+
+        true
     }
 
     pub fn remove_active(&mut self) {
-        self.list.pop_front();
+        self.list.pop();
     }
 
     pub fn add_untitled(&mut self) -> apperr::Result<&mut Document> {
@@ -160,8 +177,9 @@ impl DocumentManager {
         };
         self.gen_untitled_name(&mut doc);
 
-        self.list.push_front(doc);
-        Ok(self.list.front_mut().unwrap())
+        // In the future this could use push_mut, but it's unstable right now. As usual.
+        self.list.push(doc);
+        Ok(self.list.last_mut().unwrap())
     }
 
     pub fn gen_untitled_name(&self, doc: &mut Document) {
@@ -231,8 +249,8 @@ impl DocumentManager {
             self.remove_active();
         }
 
-        self.list.push_front(doc);
-        Ok(self.list.front_mut().unwrap())
+        self.list.push(doc);
+        Ok(self.list.last_mut().unwrap())
     }
 
     pub fn reflow_all(&self) {

crates/edit/src/bin/edit/draw_editor.rs

@@ -8,6 +8,7 @@ use edit::helpers::*;
 use edit::icu;
 use edit::input::{kbmod, vk};
 use edit::tui::*;
+use stdext::string_from_utf8_lossy_owned;
 
 use crate::localization::*;
 use crate::state::*;
@@ -58,7 +59,7 @@ fn draw_search(ctx: &mut Context, state: &mut State) {
         // If the selection is empty, focus the search input field.
         // Otherwise, focus the replace input field, if it exists.
         if let Some(selection) = doc.buffer.borrow_mut().extract_user_selection(false) {
-            state.search_needle = String::from_utf8_lossy_owned(selection);
+            state.search_needle = string_from_utf8_lossy_owned(selection);
             focus = state.wants_search.kind;
         }
     }

crates/edit/src/bin/edit/draw_filepicker.rs

@@ -11,6 +11,7 @@ use edit::input::{kbmod, vk};
 use edit::tui::*;
 use edit::{icu, path};
 use stdext::arena::scratch_arena;
+use stdext::collections::BVec;
 
 use crate::localization::*;
 use crate::state::*;
@@ -344,14 +345,7 @@ fn draw_dialog_saveas_refresh_files(state: &mut State) {
         entries.sort_unstable_by(|a, b| {
             let a = a.as_bytes();
             let b = b.as_bytes();
-
-            let a_is_dir = a.last() == Some(&b'/');
-            let b_is_dir = b.last() == Some(&b'/');
-
-            match b_is_dir.cmp(&a_is_dir) {
-                Ordering::Equal => icu::compare_strings(a, b),
-                other => other,
-            }
+            icu::compare_strings(a, b)
         });
     }
 
@@ -376,9 +370,10 @@ fn update_autocomplete_suggestions(state: &mut State) {
     // The problem is finding the upper bound. Here I'm using a trick:
     // By appending U+10FFFF (the highest possible Unicode code point)
     // we create a needle that naturally yields an upper bound.
-    let mut needle_upper_bound = Vec::with_capacity_in(needle.len() + 4, &*scratch);
-    needle_upper_bound.extend_from_slice(needle);
-    needle_upper_bound.extend_from_slice(b"\xf4\x8f\xbf\xbf");
+    let mut needle_upper_bound = BVec::empty();
+    needle_upper_bound.reserve(&*scratch, needle.len() + 4);
+    needle_upper_bound.extend_from_slice(&*scratch, needle);
+    needle_upper_bound.extend_from_slice(&*scratch, b"\xf4\x8f\xbf\xbf");
 
     if let Some(dirs_files) = &state.file_picker_entries {
         'outer: for entries in &dirs_files[1..] {

crates/edit/src/bin/edit/draw_menubar.rs

@@ -166,7 +166,7 @@ pub fn draw_dialog_about(ctx: &mut Context, state: &mut State) {
             ctx.attr_overflow(Overflow::TruncateHead);
             ctx.attr_position(Position::Center);
 
-            ctx.label("copyright", "Copyright (c) Microsoft Corp 2025");
+            ctx.label("copyright", "Copyright (c) Microsoft Corporation");
             ctx.attr_overflow(Overflow::TruncateTail);
             ctx.attr_position(Position::Center);
 

crates/edit/src/bin/edit/draw_statusbar.rs

@@ -10,6 +10,7 @@ use edit::lsh::LANGUAGES;
 use edit::tui::*;
 use stdext::arena::scratch_arena;
 use stdext::arena_format;
+use stdext::collections::BVec;
 
 use crate::localization::*;
 use crate::state::*;
@@ -347,14 +348,14 @@ fn encoding_picker_update_list(state: &mut State) {
 
     let encodings = icu::get_available_encodings();
     let scratch = scratch_arena(None);
-    let mut matches = Vec::new_in(&*scratch);
+    let mut matches = BVec::empty();
 
     for enc in encodings.all {
         let local_scratch = scratch_arena(Some(&scratch));
         let (score, _) = score_fuzzy(&local_scratch, enc.label, needle, true);
 
         if score > 0 {
-            matches.push((score, *enc));
+            matches.push(&*scratch, (score, *enc));
         }
     }