@tishlang/tish-format 1.0.13 → 2.0.1

package/crates/tish_builtins/src/iterator.rs

@@ -0,0 +1,129 @@
+//! JS-style iterator objects for `Map`/`Set` (`.values()` / `.keys()` / `.entries()`).
+//!
+//! Like [`crate::collections`] and [`crate::date`], an iterator is a plain `Value::Object`
+//! whose `next` method is a per-instance `Value::native` closure capturing a snapshot of the
+//! items plus a shared position cell — so the one implementation works on every backend with
+//! no new `Value` variant. `next()` returns `{ value, done }`; once exhausted it keeps
+//! returning `{ value: null, done: true }`.
+//!
+//! The runtimes drive iteration through [`tishlang_core::drain_iterator`], which calls `next()`
+//! until `done` — that's how these objects work in `for…of`, spread, and `Array.from`. The
+//! snapshot is taken when the iterator is built (`.values()` is called), matching how the old
+//! array-returning version behaved; mid-iteration mutation of the source is not reflected (a
+//! live iterator is a follow-up).
+
+use std::sync::Arc;
+
+use tishlang_core::{ObjectMap, Value, VmRef};
+
+/// Build a single-use iterator object over `items`: `{ next() -> { value, done } }`.
+pub fn array_iterator(items: Vec<Value>) -> Value {
+    let items: VmRef<Vec<Value>> = VmRef::new(items);
+    let pos: VmRef<usize> = VmRef::new(0);
+
+    let mut m = ObjectMap::default();
+    {
+        // Bulk-drain fast path for `for…of` / spread: return all REMAINING items (from the current
+        // position) as one array and exhaust the iterator — equivalent to calling `next()` until
+        // `done`, but with no per-element `{ value, done }` allocation. `drain_iterator` prefers this
+        // when present; manual `.next()` and partial consumption still work (it respects `pos`).
+        let items = items.clone();
+        let pos = pos.clone();
+        m.insert(
+            Arc::from("__drain__"),
+            Value::native(move |_args: &[Value]| {
+                let i = *pos.borrow();
+                let b = items.borrow();
+                let rest: Vec<Value> = if i < b.len() { b[i..].to_vec() } else { Vec::new() };
+                let len = b.len();
+                drop(b);
+                *pos.borrow_mut() = len;
+                Value::Array(VmRef::new(rest))
+            }),
+        );
+    }
+    {
+        let items = items.clone();
+        let pos = pos.clone();
+        m.insert(
+            Arc::from("next"),
+            Value::native(move |_args: &[Value]| {
+                let i = *pos.borrow();
+                // Read the element (or note exhaustion) without holding the items borrow
+                // across the position write — two different `VmRef`s, but keep it tidy.
+                let (value, done) = {
+                    let b = items.borrow();
+                    if i < b.len() {
+                        (b[i].clone(), false)
+                    } else {
+                        (Value::Null, true)
+                    }
+                };
+                if !done {
+                    *pos.borrow_mut() = i + 1;
+                }
+                let mut r = ObjectMap::default();
+                r.insert(Arc::from("value"), value);
+                r.insert(Arc::from("done"), Value::Bool(done));
+                Value::object(r)
+            }),
+        );
+    }
+    Value::object(m)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn call(obj: &Value, name: &str) -> Value {
+        let Value::Object(o) = obj else { panic!("not an object") };
+        let m = o.borrow().strings.get(name).cloned().expect("method missing");
+        let Value::Function(f) = m else { panic!("{name} is not callable") };
+        f.call(&[])
+    }
+    fn get(obj: &Value, key: &str) -> Value {
+        let Value::Object(o) = obj else { return Value::Null };
+        o.borrow().strings.get(key).cloned().unwrap_or(Value::Null)
+    }
+    fn num(v: &Value) -> f64 {
+        match v {
+            Value::Number(n) => *n,
+            _ => f64::NAN,
+        }
+    }
+    fn nums(v: &Value) -> Vec<f64> {
+        match v {
+            Value::Array(a) => a.borrow().iter().map(num).collect(),
+            _ => vec![],
+        }
+    }
+
+    #[test]
+    fn next_yields_each_then_done() {
+        let it = array_iterator(vec![Value::Number(1.0), Value::Number(2.0)]);
+        let r1 = call(&it, "next");
+        assert_eq!(num(&get(&r1, "value")), 1.0);
+        assert!(!get(&r1, "done").is_truthy());
+        assert_eq!(num(&get(&call(&it, "next"), "value")), 2.0);
+        // exhausted — and it keeps reporting done.
+        assert!(get(&call(&it, "next"), "done").is_truthy());
+        assert!(get(&call(&it, "next"), "done").is_truthy());
+    }
+
+    #[test]
+    fn drain_returns_all_and_exhausts() {
+        let it = array_iterator(vec![Value::Number(1.0), Value::Number(2.0), Value::Number(3.0)]);
+        assert_eq!(nums(&call(&it, "__drain__")), vec![1.0, 2.0, 3.0]);
+        // draining exhausts the iterator (matches calling next() until done).
+        assert!(get(&call(&it, "next"), "done").is_truthy());
+    }
+
+    #[test]
+    fn drain_respects_current_position() {
+        let it = array_iterator(vec![Value::Number(1.0), Value::Number(2.0), Value::Number(3.0)]);
+        call(&it, "next"); // consume the first
+        assert_eq!(nums(&call(&it, "__drain__")), vec![2.0, 3.0]);
+        assert_eq!(nums(&call(&it, "__drain__")), Vec::<f64>::new()); // already drained
+    }
+}

package/crates/tish_builtins/src/lib.rs

@@ -5,12 +5,17 @@
 //! and native signatures.
 
 pub mod array;
+pub mod collections;
 pub mod construct;
+pub mod date;
 pub mod globals;
 pub mod helpers;
+pub mod iterator;
 pub mod math;
+pub mod number;
 pub mod object;
 pub mod string;
 pub mod symbol;
+pub mod typedarrays;
 
 pub use tishlang_core::Value;

package/crates/tish_builtins/src/number.rs

@@ -0,0 +1,96 @@
+//! Number builtin methods.
+//!
+//! Canonical, backend-agnostic implementations of `Number.prototype` methods.
+//! The VM (`get_member`), the Rust runtime (`tishlang_runtime::number_to_fixed`),
+//! and the tree-walk interpreter all route through here so every backend produces
+//! byte-identical output — see `tish/docs/full-backend-parity-plan.md` (Workstream A).
+
+use tishlang_core::Value;
+
+/// `Number.prototype.toFixed(digits)` — ECMA-262 §21.1.3.3.
+///
+/// Formats the number using fixed-point notation with `digits` fraction digits.
+/// `digits` is clamped to 0–20 (ECMA range) and defaults to 0 when absent/non-numeric,
+/// matching `(1.5).toFixed() === "2"`. A non-number receiver yields `"NaN"`.
+pub fn to_fixed(n: &Value, digits: &Value) -> Value {
+    let num = match n {
+        Value::Number(x) => *x,
+        _ => f64::NAN,
+    };
+    let d = match digits {
+        Value::Number(x) => (*x as i32).clamp(0, 20),
+        _ => 0,
+    } as usize;
+    Value::String(format!("{:.*}", d, num).into())
+}
+
+/// `Number.prototype.toString([radix])` — ECMA-262 §21.1.3.6.
+///
+/// Radix defaults to 10 (canonical JS number formatting). For radix 2–36 the value is
+/// rendered in that base: sign, integer part via repeated division, and a fractional part
+/// (bounded to 52 digits, like V8). NaN / ±Infinity stringify as in base 10 regardless of
+/// radix. An out-of-range radix yields `"RadixError"` so the caller can surface a RangeError.
+pub fn to_string(n: &Value, radix: &Value) -> Value {
+    let num = match n {
+        Value::Number(x) => *x,
+        _ => f64::NAN,
+    };
+    let r = match radix {
+        Value::Number(x) => *x as i64,
+        _ => 10,
+    };
+    match number_to_string_radix(num, r) {
+        Some(s) => Value::String(s.into()),
+        None => Value::String("RadixError".into()),
+    }
+}
+
+/// Backend-agnostic core of `Number.prototype.toString`: works on a plain `f64` so the
+/// tree-walk interpreter (whose `Value` is a distinct type) can share the exact same
+/// formatting. Returns `None` for an out-of-range radix (caller surfaces a RangeError).
+pub fn number_to_string_radix(num: f64, radix: i64) -> Option<String> {
+    if !(2..=36).contains(&radix) {
+        return None;
+    }
+    if radix == 10 || num.is_nan() || num.is_infinite() {
+        return Some(tishlang_core::js_number_to_string(num));
+    }
+    let radix = radix as u32;
+    const DIGITS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";
+    let negative = num < 0.0;
+    let value = num.abs();
+    let int_part = value.trunc();
+    let mut frac = value - int_part;
+
+    // Integer part: collect base-`radix` digits least-significant first, then reverse.
+    let mut int_digits = Vec::new();
+    let mut i = int_part;
+    if i == 0.0 {
+        int_digits.push(b'0');
+    }
+    while i >= 1.0 {
+        let d = (i % radix as f64) as usize;
+        int_digits.push(DIGITS[d]);
+        i = (i / radix as f64).trunc();
+    }
+    int_digits.reverse();
+    let mut out = String::with_capacity(int_digits.len() + 2);
+    if negative {
+        out.push('-');
+    }
+    out.push_str(std::str::from_utf8(&int_digits).unwrap());
+
+    // Fractional part: multiply-by-radix, emitting the integer overflow each step.
+    if frac > 0.0 {
+        out.push('.');
+        let mut count = 0;
+        while frac > 0.0 && count < 52 {
+            frac *= radix as f64;
+            let d = frac.trunc() as usize;
+            out.push(DIGITS[d] as char);
+            frac -= frac.trunc();
+            count += 1;
+        }
+    }
+    Some(out)
+}

package/crates/tish_builtins/src/object.rs

@@ -4,7 +4,7 @@
 //! Functions will be migrated here from tishlang_runtime and tishlang_eval.
 
 use std::sync::Arc;
-use tishlang_core::{ObjectData, ObjectMap, Value, VmRef};
+use tishlang_core::{ObjectData, PropMap, Value, VmRef};
 
 /// Create a new empty object Value.
 pub fn new() -> Value {
@@ -14,7 +14,7 @@ pub fn new() -> Value {
 /// Create a new object Value with a given capacity.
 pub fn with_capacity(capacity: usize) -> Value {
     Value::Object(VmRef::new(ObjectData {
-        strings: ObjectMap::with_capacity(capacity),
+        strings: PropMap::with_capacity(capacity),
         symbols: None,
     }))
 }

package/crates/tish_builtins/src/string.rs

@@ -4,7 +4,6 @@
 //! JavaScript, matching .length and .charAt(). Byte offsets are never exposed.
 
 use crate::helpers::normalize_index;
-use std::sync::Arc;
 use tishlang_core::Value;
 use tishlang_core::VmRef;
 
@@ -25,7 +24,7 @@ fn char_to_byte_offset(s: &str, char_index: usize) -> usize {
 
 /// Create a new string Value from a string slice.
 pub fn from_str(s: &str) -> Value {
-    Value::String(Arc::from(s))
+    Value::String(tishlang_core::ArcStr::from(s))
 }
 
 /// Get the length of a string (character count).
@@ -118,7 +117,7 @@ pub fn index_of(s: &Value, search: &Value, from: Option<&Value>) -> Value {
             _ => 0,
         };
         let byte_start = char_to_byte_offset(s, from_char);
-        let search_str = search.as_ref();
+        let search_str = search.as_str();
         if let Some(byte_pos) = s[byte_start..].find(search_str) {
             let char_idx = from_char + byte_to_char_index(&s[byte_start..], byte_pos);
             Value::Number(char_idx as f64)
@@ -141,7 +140,7 @@ pub fn includes(s: &Value, search: &Value, from: Option<&Value>) -> Value {
             _ => 0,
         };
         let byte_start = char_to_byte_offset(s, from_char);
-        Value::Bool(s[byte_start..].contains(search.as_ref()))
+        Value::Bool(s[byte_start..].contains(search.as_str()))
     } else {
         Value::Bool(false)
     }
@@ -218,8 +217,8 @@ pub fn substr(s: &Value, start: &Value, length: &Value) -> Value {
 pub fn split(s: &Value, sep: &Value) -> Value {
     if let Value::String(s) = s {
         let separator = match sep {
-            Value::String(ss) => ss.as_ref(),
-            _ => return Value::Array(VmRef::new(vec![Value::String(Arc::clone(s))])),
+            Value::String(ss) => ss.as_str(),
+            _ => return Value::Array(VmRef::new(vec![Value::String(s.clone())])),
         };
         let parts: Vec<Value> = s
             .split(separator)
@@ -257,7 +256,7 @@ pub fn to_lower_case(s: &Value) -> Value {
 
 pub fn starts_with(s: &Value, search: &Value) -> Value {
     if let (Value::String(s), Value::String(search)) = (s, search) {
-        Value::Bool(s.starts_with(search.as_ref()))
+        Value::Bool(s.starts_with(search.as_str()))
     } else {
         Value::Bool(false)
     }
@@ -265,7 +264,7 @@ pub fn starts_with(s: &Value, search: &Value) -> Value {
 
 pub fn ends_with(s: &Value, search: &Value) -> Value {
     if let (Value::String(s), Value::String(search)) = (s, search) {
-        Value::Bool(s.ends_with(search.as_ref()))
+        Value::Bool(s.ends_with(search.as_str()))
     } else {
         Value::Bool(false)
     }
@@ -274,11 +273,11 @@ pub fn ends_with(s: &Value, search: &Value) -> Value {
 fn replace_impl(s: &Value, search: &Value, replacement: &Value, all: bool) -> Value {
     if let Value::String(s) = s {
         let search_str = match search {
-            Value::String(ss) => ss.as_ref(),
-            _ => return Value::String(Arc::clone(s)),
+            Value::String(ss) => ss.as_str(),
+            _ => return Value::String(s.clone()),
         };
         let repl_str = match replacement {
-            Value::String(ss) => ss.as_ref(),
+            Value::String(ss) => ss.as_str(),
             _ => "",
         };
         let result = if all {
@@ -305,8 +304,8 @@ pub fn replace_all(s: &Value, search: &Value, replacement: &Value) -> Value {
 /// character needs escaping. Matches TFB's fortunes verifier byte-for-byte.
 pub fn escape_html(s: &Value) -> Value {
     let input = match s {
-        Value::String(s) => s.as_ref(),
-        Value::Null => return Value::String(Arc::from("")),
+        Value::String(s) => s.as_str(),
+        Value::Null => return Value::String(tishlang_core::ArcStr::from("")),
         _ => return Value::Null,
     };
     let bytes = input.as_bytes();
@@ -321,10 +320,10 @@ pub fn escape_html(s: &Value) -> Value {
         }
     }
     if extra == 0 {
-        return Value::String(Arc::clone(match s {
-            Value::String(s) => s,
+        return Value::String(match s {
+            Value::String(s) => s.clone(),
             _ => unreachable!(),
-        }));
+        });
     }
     let mut out = String::with_capacity(input.len() + extra);
     let mut last = 0usize;
@@ -344,7 +343,7 @@ pub fn escape_html(s: &Value) -> Value {
         }
     }
     out.push_str(&input[last..]);
-    Value::String(Arc::from(out))
+    Value::String(tishlang_core::ArcStr::from(out))
 }
 
 fn char_at_idx(s: &str, idx: usize) -> Option<char> {
@@ -395,15 +394,15 @@ fn pad_impl(s: &Value, target_len: &Value, pad: &Value, at_start: bool) -> Value
     if let Value::String(s) = s {
         let target_len = match target_len {
             Value::Number(n) => *n as usize,
-            _ => return Value::String(Arc::clone(s)),
+            _ => return Value::String(s.clone()),
         };
         let pad_str = match pad {
-            Value::String(p) if !p.is_empty() => p.as_ref(),
+            Value::String(p) if !p.is_empty() => p.as_str(),
             _ => " ",
         };
         let char_count = s.chars().count();
         if char_count >= target_len {
-            return Value::String(Arc::clone(s));
+            return Value::String(s.clone());
         }
         let needed = target_len - char_count;
         let padding: String = pad_str.chars().cycle().take(needed).collect();

package/crates/tish_builtins/src/symbol.rs

@@ -44,7 +44,7 @@ fn symbol_key_for_impl(args: &[Value]) -> Value {
         Some(Value::Symbol(s)) => s
             .registry_key
             .as_ref()
-            .map(|k| Value::String(Arc::clone(k)))
+            .map(|k| Value::String(tishlang_core::ArcStr::from(k.as_ref())))
             .unwrap_or(Value::Null),
         _ => Value::Null,
     }