perf: remove VecDeque in CharIndices (#179)

Author: SyMind

Cargo.lock

@@ -45,7 +45,6 @@ simd-json = "0.14.3"
 
 [dev-dependencies]
 twox-hash = "2.1.0"
-base64-simd = "0.8.0"
 regex = "1.11.1"
 criterion = { version = "0.5.1", default-features = false }
 

Cargo.toml

@@ -2,7 +2,6 @@
 
 use std::{
   borrow::Cow,
-  collections::VecDeque,
   hash::Hash,
   ops::{Bound, RangeBounds},
   rc::Rc,
@@ -136,7 +135,7 @@ impl<'a> Rope<'a> {
   }
 
   /// Returns an iterator over the characters and their byte positions.
-  pub fn char_indices(&self) -> CharIndices<'_, 'a> {
+  pub fn char_indices(&self) -> CharIndices<'_> {
     match &self.repr {
       Repr::Light(s) => CharIndices {
         iter: CharIndicesEnum::Light {
@@ -146,8 +145,9 @@ impl<'a> Rope<'a> {
       Repr::Full(data) => CharIndices {
         iter: CharIndicesEnum::Full {
           chunks: data,
-          char_indices: VecDeque::new(),
           chunk_index: 0,
+          iter: data[0].0.char_indices(),
+          start_pos: 0,
         },
       },
     }
@@ -729,51 +729,58 @@ impl<'a> Iterator for Lines<'_, 'a> {
   }
 }
 
-enum CharIndicesEnum<'a, 'b> {
+enum CharIndicesEnum<'a> {
   Light {
-    iter: std::str::CharIndices<'b>,
+    iter: std::str::CharIndices<'a>,
   },
   Full {
-    chunks: &'a [(&'b str, usize)],
-    char_indices: VecDeque<(usize, char)>,
+    chunks: &'a [(&'a str, usize)],
     chunk_index: usize,
+    start_pos: usize,
+    iter: std::str::CharIndices<'a>,
   },
 }
 
-pub struct CharIndices<'a, 'b> {
-  iter: CharIndicesEnum<'a, 'b>,
+pub struct CharIndices<'a> {
+  iter: CharIndicesEnum<'a>,
 }
 
-impl Iterator for CharIndices<'_, '_> {
+impl Iterator for CharIndices<'_> {
   type Item = (usize, char);
 
   fn next(&mut self) -> Option<Self::Item> {
     match &mut self.iter {
       CharIndicesEnum::Light { iter } => iter.next(),
       CharIndicesEnum::Full {
         chunks,
-        char_indices,
         chunk_index,
+        iter,
+        start_pos,
       } => {
-        if let Some(item) = char_indices.pop_front() {
-          return Some(item);
+        if let Some((i, c)) = iter.next() {
+          return Some((*start_pos + i, c));
         }
-
-        if *chunk_index >= chunks.len() {
-          return None;
-        }
-
-        // skip empty chunks
-        while *chunk_index < chunks.len() && chunks[*chunk_index].0.is_empty() {
+        loop {
+          if *chunk_index == chunks.len() - 1 {
+            return None;
+          }
           *chunk_index += 1;
-        }
+          // SAFETY: We just checked bounds above
+          let (chunk, next_start_pos) =
+            unsafe { chunks.get_unchecked(*chunk_index) };
+
+          // Skip empty chunks without creating iterators
+          if chunk.is_empty() {
+            continue;
+          }
 
-        let (chunk, start_pos) = chunks[*chunk_index];
+          *iter = chunk.char_indices();
+          *start_pos = *next_start_pos;
 
-        char_indices
-          .extend(chunk.char_indices().map(|(i, c)| (start_pos + i, c)));
-        *chunk_index += 1;
-        char_indices.pop_front()
+          if let Some((i, c)) = iter.next() {
+            return Some((*start_pos + i, c));
+          }
+        }
       }
     }
   }