chore(interpreter): refactor field writting into two helpers

Author: Alonely0

interpreter/src/vm/symbols.rs

@@ -339,23 +339,25 @@ impl Record {
         mode: ExecMode,
     ) -> Result<(), RegexError> {
         if n == 0 {
-            self.fields = None;
-            match val {
-                Value::String(Cow::Owned(s)) => {
-                    self.raw = s;
-                }
-                Value::String(Cow::Borrowed(s)) => {
-                    self.raw.clear();
-                    self.raw.extend_from_slice(s);
-                }
-                val => {
-                    self.raw.clear();
-                    let _ = write!(self.raw, "{val}");
-                }
-            }
-            return Ok(());
+            self.write_record_raw(val);
+            Ok(())
+        } else {
+            self.write_field_raw(val, n, symbols, mode)
         }
+    }
 
+    fn write_record_raw(&mut self, val: Value<'_>) {
+        self.fields = None;
+        val.move_string_into(&mut self.raw);
+    }
+
+    fn write_field_raw(
+        &mut self,
+        val: Value<'_>,
+        n: usize,
+        symbols: &mut SymbolTable<'_>,
+        mode: ExecMode,
+    ) -> Result<(), RegexError> {
         let mut fields = take(self.split_fields_raw(symbols, mode)?);
         if n >= fields.len() {
             fields.resize(n + 1, Span::from(self.raw.len()..self.raw.len()));
@@ -366,12 +368,10 @@ impl Record {
 
         let mut ofs = SmallVec::<[u8; 16]>::new();
         let _ = write!(ofs, "{}", symbols.ofs);
-        let mut first = true;
         for (i, span) in fields.iter_mut().enumerate().skip(1) {
-            if !first {
+            if i > 1 {
                 buf.extend_from_slice(&ofs);
             }
-            first = false;
 
             let start = buf.len();
             if i == n {

interpreter/src/vm/types.rs

@@ -149,18 +149,36 @@ impl<'a> Value<'a> {
         })
     }
 
-    pub fn write_string(&self, f: &mut Vec<u8>) {
+    pub fn write_string(&self, out: &mut Vec<u8>) {
         match self {
-            Self::String(s) | Self::Regex(s) => f.extend_from_slice(s),
-            Self::Float(n) => write!(f, "{n}").unwrap(),
-            Self::Int(n) => write!(f, "{n}").unwrap(),
-            &Self::Bool(false) => f.push(b'0'),
-            &Self::Bool(true) => f.push(b'1'),
+            Self::String(s) | Self::Regex(s) => out.extend_from_slice(s),
+            Self::Float(n) => write!(out, "{n}").unwrap(),
+            Self::Int(n) => write!(out, "{n}").unwrap(),
+            &Self::Bool(false) => out.push(b'0'),
+            &Self::Bool(true) => out.push(b'1'),
             Self::Array(_) => panic!("Attempted to use array in scalar context!"),
             _ => {}
         }
     }
 
+    /// Efficiently replaces the contents of `out` with the string form of the
+    /// value. Always reuses either buffer.
+    pub fn move_string_into(self, out: &mut Vec<u8>) {
+        match self {
+            Value::String(Cow::Owned(s)) => {
+                *out = s;
+            }
+            Value::String(Cow::Borrowed(s)) => {
+                out.clear();
+                out.extend_from_slice(s);
+            }
+            _ => {
+                out.clear();
+                self.write_string(out);
+            }
+        }
+    }
+
     pub fn string_size_hint(&self) -> usize {
         match self {
             Self::String(s) | Self::Regex(s) => s.len(),