@tishlang/tish 2.2.5 → 2.8.0

package/crates/tish_core/src/json.rs

@@ -3,13 +3,70 @@
 use crate::{Value, VmRef};
 use std::sync::Arc;
 
+/// Per-`json_parse`-call cache of object-key text → shared `Arc<str>`. A JSON array of records
+/// repeats the same handful of keys across thousands of objects; interning allocates each key
+/// once and `Arc::clone`s it thereafter, instead of a fresh `Arc<str>` allocation per occurrence.
+type KeyCache = ahash::AHashMap<Box<str>, Arc<str>>;
+
+#[inline]
+fn intern_key(cache: &mut KeyCache, s: &str) -> Arc<str> {
+    if let Some(existing) = cache.get(s) {
+        return Arc::clone(existing);
+    }
+    let arc: Arc<str> = Arc::from(s);
+    cache.insert(Box::from(s), Arc::clone(&arc));
+    arc
+}
+
+/// Append `n` to `buf` exactly as JS `JSON.stringify` formats a number. Integer-valued finite
+/// numbers within the safe-integer range (`|n| < 2^53`) take a fast `i64` path — bit-identical to
+/// JS for every such value (verified against Node over 100k values) and far cheaper than the `f64`
+/// formatter. Everything else uses the ECMAScript `Number::toString` (`js_number_to_string`),
+/// which matches JS where Rust's `{}` Display would not (e.g. `1e21`, `1e-7`). NaN/∞ → `null`.
+/// Public so the interpreter's separate JSON path formats numbers identically (single source of
+/// truth → interp/vm/native/node agree).
+#[inline]
+pub fn write_json_number(buf: &mut String, n: f64) {
+    if n.is_nan() || n.is_infinite() {
+        buf.push_str("null");
+        return;
+    }
+    if n.fract() == 0.0 && n.abs() < 9_007_199_254_740_992.0 {
+        let mut b = itoa::Buffer::new();
+        buf.push_str(b.format(n as i64));
+        return;
+    }
+    crate::js_number_to_string_into(buf, n);
+}
+
+/// Scan a string body (the input with its opening `"` already removed) for the closing quote.
+/// Returns `Ok(Some((body, rest)))` when the string is escape-free — `body` is the raw contents and
+/// `rest` is the input just past the closing quote, so the value is built in a single allocation
+/// with no per-char decode. Returns `Ok(None)` on the first backslash (caller uses the escape
+/// decoder) and `Err` if unterminated. Only stops on the ASCII bytes `"`/`\\`, so the byte index
+/// always lands on a UTF-8 char boundary — multi-byte sequences pass through inside `body` intact.
+#[inline]
+fn scan_escape_free(body: &str) -> Result<Option<(&str, &str)>, String> {
+    let bytes = body.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\\' => return Ok(None),
+            b'"' => return Ok(Some((&body[..i], &body[i + 1..]))),
+            _ => i += 1,
+        }
+    }
+    Err("Unterminated string".to_string())
+}
+
 /// Parse JSON string into a Value.
 pub fn json_parse(json: &str) -> Result<Value, String> {
     let json = json.trim();
     if json.is_empty() {
         return Err("SyntaxError: Unexpected end of JSON input".to_string());
     }
-    let (value, rest) = parse_value(json, 0)?;
+    let mut cache = KeyCache::default();
+    let (value, rest) = parse_value(json, 0, &mut cache)?;
     if !rest.trim().is_empty() {
         return Err("SyntaxError: Unexpected token at end of JSON".to_string());
     }
@@ -39,17 +96,7 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
         Value::Null => buf.push_str("null"),
         Value::Bool(true) => buf.push_str("true"),
         Value::Bool(false) => buf.push_str("false"),
-        Value::Number(n) => {
-            if n.is_nan() || n.is_infinite() {
-                buf.push_str("null");
-            } else {
-                // `write!` avoids the heap allocation that `to_string`
-                // produces. The f64 → decimal formatter is the same
-                // either way (`std::fmt::Display`).
-                use std::fmt::Write;
-                let _ = write!(buf, "{}", n);
-            }
-        }
+        Value::Number(n) => write_json_number(buf, *n),
         Value::String(s) => {
             buf.push('"');
             escape_json_string_into(buf, s);
@@ -69,16 +116,11 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
         Value::NumberArray(arr) => {
             let borrowed = arr.borrow();
             buf.push('[');
-            use std::fmt::Write;
             for (i, n) in borrowed.iter().enumerate() {
                 if i > 0 {
                     buf.push(',');
                 }
-                if n.is_nan() || n.is_infinite() {
-                    buf.push_str("null");
-                } else {
-                    let _ = write!(buf, "{}", n);
-                }
+                write_json_number(buf, *n);
             }
             buf.push(']');
         }
@@ -153,7 +195,11 @@ fn escape_json_string_into(buf: &mut String, s: &str) {
 /// whole process (uncatchable, SIGABRT). 128 matches serde_json's default limit.
 const MAX_JSON_DEPTH: usize = 128;
 
-fn parse_value(input: &str, depth: usize) -> Result<(Value, &str), String> {
+fn parse_value<'a>(
+    input: &'a str,
+    depth: usize,
+    cache: &mut KeyCache,
+) -> Result<(Value, &'a str), String> {
     let input = input.trim_start();
     if input.is_empty() {
         return Err("Unexpected end of JSON input".to_string());
@@ -163,8 +209,8 @@ fn parse_value(input: &str, depth: usize) -> Result<(Value, &str), String> {
         'n' => parse_null(input),
         't' | 'f' => parse_bool(input),
         '"' => parse_string(input),
-        '[' => parse_array(input, depth),
-        '{' => parse_object(input, depth),
+        '[' => parse_array(input, depth, cache),
+        '{' => parse_object(input, depth, cache),
         c if c == '-' || c.is_ascii_digit() => parse_number(input),
         c => Err(format!("Unexpected character '{}' in JSON", c)),
     }
@@ -189,6 +235,31 @@ fn parse_bool(input: &str) -> Result<(Value, &str), String> {
 }
 
 fn parse_string(input: &str) -> Result<(Value, &str), String> {
+    // Fast path: an escape-free string is a direct slice of the input — one allocation, no decode.
+    let body = &input[1..]; // skip opening quote (ASCII, safe byte index)
+    if let Some((s, rest)) = scan_escape_free(body)? {
+        return Ok((Value::String(s.into()), rest));
+    }
+    parse_string_escaped(input)
+}
+
+/// Read an object key, interning it through `cache` so repeated keys share one `Arc<str>` instead
+/// of allocating a fresh one per occurrence. Escape-free keys (the common case) look up the cache
+/// with the borrowed slice — zero allocations on a hit.
+fn parse_key<'a>(input: &'a str, cache: &mut KeyCache) -> Result<(Arc<str>, &'a str), String> {
+    let body = &input[1..];
+    if let Some((s, rest)) = scan_escape_free(body)? {
+        return Ok((intern_key(cache, s), rest));
+    }
+    let (val, rest) = parse_string_escaped(input)?;
+    match val {
+        Value::String(s) => Ok((intern_key(cache, s.as_str()), rest)),
+        _ => unreachable!("parse_string_escaped always yields Value::String"),
+    }
+}
+
+/// Decode a JSON string that contains at least one escape (the slow path).
+fn parse_string_escaped(input: &str) -> Result<(Value, &str), String> {
     let input = &input[1..]; // skip opening quote
     let mut result = String::new();
     let mut chars = input.chars().peekable();
@@ -267,19 +338,25 @@ fn parse_number(input: &str) -> Result<(Value, &str), String> {
     let bytes = input.as_bytes();
     let mut end = 0;
 
-    if bytes.first() == Some(&b'-') {
+    let neg = bytes.first() == Some(&b'-');
+    if neg {
         end += 1;
     }
+    let int_start = end;
     while end < bytes.len() && bytes[end].is_ascii_digit() {
         end += 1;
     }
+    let int_len = end - int_start;
+    let mut is_integer = true;
     if bytes.get(end) == Some(&b'.') {
+        is_integer = false;
         end += 1;
         while end < bytes.len() && bytes[end].is_ascii_digit() {
             end += 1;
         }
     }
     if matches!(bytes.get(end), Some(&b'e') | Some(&b'E')) {
+        is_integer = false;
         end += 1;
         if matches!(bytes.get(end), Some(&b'+') | Some(&b'-')) {
             end += 1;
@@ -291,13 +368,27 @@ fn parse_number(input: &str) -> Result<(Value, &str), String> {
 
     // `end` lands on an ASCII boundary, so slicing `input` by byte index is valid.
     let num_str = &input[..end];
+    // Integer fast-path: a pure integer of ≤15 digits fits `i64` and is exact in `f64`
+    // (|value| < 10^15 < 2^53), so `i64 as f64` equals the full float parse but is far cheaper —
+    // and JSON arrays of records are integer-heavy. Negative zero is excluded: `i64` loses the
+    // sign, but `JSON.parse("-0")` must yield `-0.0` (matches std `f64` parse and Node).
+    if is_integer && (1..=15).contains(&int_len) {
+        if let Ok(i) = num_str.parse::<i64>() {
+            let n = if neg && i == 0 { -0.0 } else { i as f64 };
+            return Ok((Value::Number(n), &input[end..]));
+        }
+    }
     num_str
         .parse::<f64>()
         .map(|n| (Value::Number(n), &input[end..]))
         .map_err(|_| format!("Invalid number: {}", num_str))
 }
 
-fn parse_array(input: &str, depth: usize) -> Result<(Value, &str), String> {
+fn parse_array<'a>(
+    input: &'a str,
+    depth: usize,
+    cache: &mut KeyCache,
+) -> Result<(Value, &'a str), String> {
     if depth >= MAX_JSON_DEPTH {
         return Err("JSON nesting too deep".to_string());
     }
@@ -310,7 +401,7 @@ fn parse_array(input: &str, depth: usize) -> Result<(Value, &str), String> {
     }
 
     loop {
-        let (value, rest) = parse_value(input, depth + 1)?;
+        let (value, rest) = parse_value(input, depth + 1, cache)?;
         items.push(value);
         input = rest.trim_start();
 
@@ -322,17 +413,28 @@ fn parse_array(input: &str, depth: usize) -> Result<(Value, &str), String> {
     }
 }
 
-fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
+fn parse_object<'a>(
+    input: &'a str,
+    depth: usize,
+    cache: &mut KeyCache,
+) -> Result<(Value, &'a str), String> {
     if depth >= MAX_JSON_DEPTH {
         return Err("JSON nesting too deep".to_string());
     }
     let mut input = &input[1..]; // skip '{'
-    let mut map = crate::ObjectMap::default();
+    // Build the insertion-ordered `PropMap` directly. The old path collected into an `AHashMap`
+    // and then re-inserted every pair into a `PropMap` via `from_strings` — a wasted map + rehash
+    // per object, AND the `AHashMap` iteration order scrambled JSON key order (its `RandomState`
+    // reseeds per process), so `Object.keys` after `JSON.parse` came out in a non-spec order.
+    let mut map = crate::PropMap::new();
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix('}') {
         return Ok((
-            Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+            Value::Object(VmRef::new(crate::ObjectData {
+                strings: map,
+                symbols: None,
+            })),
             rest,
         ));
     }
@@ -343,11 +445,7 @@ fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
             return Err("Expected string key in object".to_string());
         }
 
-        let (key_val, rest) = parse_string(input)?;
-        let key: Arc<str> = match key_val {
-            Value::String(s) => Arc::from(s.as_str()),
-            _ => unreachable!(),
-        };
+        let (key, rest) = parse_key(input, cache)?;
 
         input = rest.trim_start();
         if !input.starts_with(':') {
@@ -355,7 +453,7 @@ fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
         }
         input = &input[1..];
 
-        let (value, rest) = parse_value(input, depth + 1)?;
+        let (value, rest) = parse_value(input, depth + 1, cache)?;
         map.insert(key, value);
         input = rest.trim_start();
 
@@ -363,7 +461,10 @@ fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
             Some(',') => input = &input[1..],
             Some('}') => {
                 return Ok((
-                    Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+                    Value::Object(VmRef::new(crate::ObjectData {
+                        strings: map,
+                        symbols: None,
+                    })),
                     &input[1..],
                 ));
             }

package/crates/tish_core/src/lib.rs

@@ -12,9 +12,31 @@ mod value;
 mod vmref;
 
 pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
-pub use json::{json_parse, json_stringify, json_stringify_into};
+pub use json::{json_parse, json_stringify, json_stringify_into, write_json_number};
 pub use shape::{ShapeId, DICT_SHAPE, EMPTY_SHAPE};
 pub use uri::{percent_decode, percent_encode};
 pub use arcstr::ArcStr;
 pub use value::*;
 pub use vmref::{VmReadGuard, VmRef, VmWriteGuard};
+
+/// `process.argv` for the interpreter / VM. Defaults to the host process's own `std::env::args()`,
+/// but `tish run <file> [args...]` overrides it (via [`set_process_argv`]) with a node-shaped argv
+/// `[tish-exe, <file>, args...]` so a script sees its own args — not the `run` subcommand. Compiled
+/// native binaries don't touch this; they read `std::env::args()` directly (which is already their
+/// own argv). #88
+static PROCESS_ARGV: std::sync::OnceLock<Vec<String>> = std::sync::OnceLock::new();
+
+/// Override `process.argv` for the interpreter/VM (set once by `tish run` before executing). A
+/// later call is ignored (the first override wins), matching the single-program-per-process model.
+pub fn set_process_argv(argv: Vec<String>) {
+    let _ = PROCESS_ARGV.set(argv);
+}
+
+/// The argv a script should see as `process.argv`: the [`set_process_argv`] override if present,
+/// else the host process's `std::env::args()`.
+pub fn process_argv() -> Vec<String> {
+    match PROCESS_ARGV.get() {
+        Some(v) => v.clone(),
+        None => std::env::args().collect(),
+    }
+}

package/crates/tish_core/src/value.rs

@@ -834,6 +834,31 @@ pub fn to_uint32(x: f64) -> u32 {
     }
 }
 
+/// `ToNumber` for the native boxed runtime: a `Value::Number` passes through, every other variant
+/// coerces to `NaN`. This is the same `as_number().unwrap_or(NaN)` convention used by the
+/// interpreter (`binop_number` / `to_int32`), the VM (`eval_binop`), and `ops::add`/`sub`/`mul`/`div`
+/// — so the native backend stays bit-for-bit in lock-step with them at runtime (a string/bool/null
+/// operand is `NaN`, hence `0` for bitwise). The compiler constant-folds literal cases like
+/// `"5" | 0 === 5` separately, so this only governs runtime (non-constant) operands.
+#[inline]
+pub fn to_number_value(v: &Value) -> f64 {
+    v.as_number().unwrap_or(f64::NAN)
+}
+
+/// `ToInt32` of an arbitrary [`Value`] (coerce via [`to_number_value`], then [`to_int32`]). Designed
+/// to compose in generated code: unlike a `let Value::Number(a) = &(..) else { panic!() }` block,
+/// it binds no name, so nested bitwise/shift operands can never shadow each other.
+#[inline]
+pub fn to_int32_value(v: &Value) -> i32 {
+    to_int32(to_number_value(v))
+}
+
+/// `ToUint32` companion to [`to_int32_value`].
+#[inline]
+pub fn to_uint32_value(v: &Value) -> u32 {
+    to_uint32(to_number_value(v))
+}
+
 /// Invoke a callable [`Value`]: [`Value::Function`], or an object exposing `__call` (e.g. `Symbol`).
 pub fn value_call(callee: &Value, args: &[Value]) -> Value {
     match callee {
@@ -910,20 +935,36 @@ impl std::fmt::Debug for Value {
 /// We take the shortest round-tripping digits from Rust's `{:e}` (a Ryū/Grisu-class shortest
 /// formatter, matching V8's digit choice) and lay them out per the ECMAScript rule: plain
 /// decimal when the point position `n` is in `(-6, 21]`, otherwise `d[.ddd]e±E` with `E = n-1`
-/// (sign always shown, no leading zeros in the exponent). `-0` renders as `"-0"` (matching
-/// `console.log` and tish's existing behavior).
+/// (sign always shown, no leading zeros in the exponent). This is the ECMAScript `Number::toString`
+/// used by `.toString()`, `String(n)`, `+` concatenation, and template literals, so `-0` renders as
+/// `"0"` (the sign is dropped — `(-0).toString() === "0"`). The *inspect* form (`console.log` of a
+/// bare number / array element) keeps `"-0"`; that distinction lives in [`Value::to_display_string`].
 pub fn js_number_to_string(value: f64) -> String {
+    let mut out = String::new();
+    js_number_to_string_into(&mut out, value);
+    out
+}
+
+/// Append the ECMAScript `Number::toString` of `value` to `out` — identical result to
+/// [`js_number_to_string`] but with no intermediate `String` allocation. The JSON.stringify
+/// hot path appends millions of numbers into a single buffer, so the alloc-free form matters.
+pub fn js_number_to_string_into(out: &mut String, value: f64) {
     if value.is_nan() {
-        return "NaN".to_string();
+        out.push_str("NaN");
+        return;
     }
     if value == f64::INFINITY {
-        return "Infinity".to_string();
+        out.push_str("Infinity");
+        return;
     }
     if value == f64::NEG_INFINITY {
-        return "-Infinity".to_string();
+        out.push_str("-Infinity");
+        return;
     }
     if value == 0.0 {
-        return if value.is_sign_negative() { "-0" } else { "0" }.to_string();
+        // ECMAScript `Number::toString`: both `+0` and `-0` stringify to `"0"`.
+        out.push('0');
+        return;
     }
 
     let negative = value < 0.0;
@@ -939,7 +980,6 @@ pub fn js_number_to_string(value: f64) -> String {
     let k = digits.len() as i32; // significant digit count (≤ 17 for an f64)
     let point = exp + 1; // ECMAScript's `n`: value = digits × 10^(point − k)
 
-    let mut out = String::new();
     if negative {
         out.push('-');
     }
@@ -969,13 +1009,15 @@ pub fn js_number_to_string(value: f64) -> String {
         out.push(if e >= 0 { '+' } else { '-' });
         out.push_str(&e.abs().to_string());
     }
-    out
 }
 
 impl Value {
     /// Convert value to display string (for console output).
     pub fn to_display_string(&self) -> String {
         match self {
+            // Inspect form keeps the sign of negative zero (`console.log(-0)` → `-0`), unlike the
+            // ECMAScript ToString used by `to_js_string`. See `js_number_to_string`. (#247)
+            Value::Number(n) if *n == 0.0 && n.is_sign_negative() => "-0".to_string(),
             Value::Number(n) => js_number_to_string(*n),
             Value::String(s) => s.to_string(),
             Value::Bool(b) => b.to_string(),
@@ -1046,6 +1088,9 @@ impl Value {
                 .collect::<Vec<_>>()
                 .join(","),
             Value::Object(_) => "[object Object]".to_string(),
+            // ECMAScript ToString of a number (drops `-0`'s sign), distinct from the inspect form
+            // that `to_display_string` would give for `-0`. (#247)
+            Value::Number(n) => js_number_to_string(*n),
             // Primitives (and the remaining cases) coincide with the display form.
             _ => self.to_display_string(),
         }
@@ -1148,12 +1193,18 @@ impl Value {
     // -------------------------------------------------------------------------
 
     /// Whether packed f64 arrays are enabled this run. Default: **off** (`TISH_PACKED_ARRAYS=1`
-    /// opts in). Checked at every creation site so flag changes take effect per-process.
+    /// opts in). Read once per process and cached — the VM calls this once per executed array
+    /// literal, and a `std::env::var` there is a libc env lock plus a `String` allocation per
+    /// `NewArray` for a flag that never changes after startup (#166). Set the variable before the
+    /// process starts (as the CI sweep does); mid-process toggling is not observed by design.
     /// The flag is intentionally backwards from the slot/JIT flags (those were default-on) to
     /// keep the default binary behaviour byte-identical while we validate coverage.
     #[inline]
     pub fn packed_arrays_enabled() -> bool {
-        std::env::var("TISH_PACKED_ARRAYS").map(|v| v == "1").unwrap_or(false)
+        static PACKED_ARRAYS: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+        *PACKED_ARRAYS.get_or_init(|| {
+            std::env::var("TISH_PACKED_ARRAYS").map(|v| v == "1").unwrap_or(false)
+        })
     }
 
     /// Wrap a `Vec<f64>` as a `Value::NumberArray`. Only call when `packed_arrays_enabled()`.
@@ -1310,9 +1361,11 @@ mod number_to_string_tests {
     #[test]
     fn matches_javascript_number_tostring() {
         // (value, expected) — every `expected` is what Node's `String(value)` produces.
+        // `String(-0) === "0"`: ToString drops the sign of negative zero (the inspect form keeps
+        // it, but that path is `Value::to_display_string`, not this function). (#247)
         let cases: &[(f64, &str)] = &[
             (0.0, "0"),
-            (-0.0, "-0"),
+            (-0.0, "0"),
             (123.0, "123"),
             (123.456, "123.456"),
             (0.5, "0.5"),