@tishlang/tish-lsp 2.39.0 → 3.0.0

package/crates/tish_builtins/src/number.rs

@@ -5,6 +5,12 @@
 //! 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).
 
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
 use tishlang_core::Value;
 
 /// `Number.prototype.toFixed(digits)` — ECMA-262 §21.1.3.3.
@@ -25,8 +31,16 @@ pub fn to_fixed(n: &Value, digits: &Value) -> Value {
 }
 
 /// f64-domain `Number.prototype.toFixed` so the tree-walk interpreter (distinct `Value`) shares the
-/// exact behavior. Rust's `{:.*}` rounds half-to-even (`(2.5).toFixed(0)` → "2"); JS rounds half away
-/// from zero (→ "3"), so pre-round the scaled value with `.round()` (half-away) before formatting. #247
+/// exact behavior. tish's rule (#438): round the number's *true* decimal value to `digits` places,
+/// ties away from zero — matching V8/node's observable `toFixed`.
+///
+/// The obvious `(num * 10^digits).round()` is wrong: float scaling nudges values that are actually
+/// just below a tie up over it, so `(2.675).toFixed(2)` came out `2.68` where node gives `2.67`
+/// (2.675 is stored as 2.67499999…). Instead we render the double's exact decimal expansion to well
+/// beyond `digits` — f64 fractions terminate, so a generous precision captures the real digits — then
+/// round that digit string: if the first dropped digit is ≥ 5, increment with decimal carry; else
+/// truncate. On the magnitude, "first dropped ≥ 5" is round-half-up = round-half-away-from-zero, and
+/// because the expansion is exact, non-ties round the way the true value dictates. #438
 pub fn to_fixed_str(num: f64, digits: usize) -> String {
     if num.is_nan() {
         return "NaN".to_string();
@@ -38,9 +52,61 @@ pub fn to_fixed_str(num: f64, digits: usize) -> String {
     if num.abs() >= 1e21 {
         return format!("{}", num);
     }
-    let factor = 10f64.powi(digits as i32);
-    let rounded = (num * factor).round() / factor;
-    format!("{:.*}", digits, rounded)
+
+    let negative = num.is_sign_negative() && num != 0.0;
+    let magnitude = num.abs();
+
+    // Exact-enough decimal expansion. The digit just past `digits` then reflects the double's TRUE
+    // value; +25 guard digits sit far beyond any position we inspect, so the half-to-even rounding
+    // Rust applies at the cutoff can't perturb our decision (it would take 25 consecutive 9s to carry
+    // back that far, and such a value already rounds up under the exact rule anyway).
+    let guard = digits + 25;
+    let rendered = format!("{:.*}", guard, magnitude);
+    let dot = rendered.find('.').expect("fixed formatting always has a decimal point");
+    let int_str = &rendered[..dot];
+    let frac = rendered[dot + 1..].as_bytes();
+
+    // Kept digits: the whole integer part, then `digits` fractional digits.
+    let mut ds: Vec<u8> = int_str
+        .bytes()
+        .chain(frac[..digits].iter().copied())
+        .map(|b| b - b'0')
+        .collect();
+
+    // Round half-away-from-zero on the magnitude: increment iff the first dropped digit is >= 5.
+    if frac[digits] - b'0' >= 5 {
+        let mut i = ds.len();
+        loop {
+            if i == 0 {
+                ds.insert(0, 1);
+                break;
+            }
+            i -= 1;
+            if ds[i] == 9 {
+                ds[i] = 0;
+            } else {
+                ds[i] += 1;
+                break;
+            }
+        }
+    }
+
+    // Split back into integer (all but the last `digits`) and fractional digits.
+    let int_len = ds.len() - digits;
+    let mut out = String::with_capacity(ds.len() + 2);
+    if negative {
+        out.push('-');
+    }
+    for &d in &ds[..int_len] {
+        out.push((d + b'0') as char);
+    }
+    if digits > 0 {
+        out.push('.');
+        for &d in &ds[int_len..] {
+            out.push((d + b'0') as char);
+        }
+    }
+    out
 }
 
 /// `Number.prototype.toExponential(fractionDigits?)` — ECMA-262 §21.1.3.2. Exponential notation with
@@ -270,7 +336,7 @@ pub fn number_to_string_radix(num: f64, radix: i64) -> Option<String> {
     if negative {
         out.push('-');
     }
-    out.push_str(std::str::from_utf8(&int_digits).unwrap());
+    out.push_str(core::str::from_utf8(&int_digits).unwrap());
 
     // Fractional part: multiply-by-radix, emitting the integer overflow each step.
     if frac > 0.0 {

package/crates/tish_builtins/src/object.rs

@@ -3,7 +3,11 @@
 //! This module will contain shared object method implementations.
 //! Functions will be migrated here from tishlang_runtime and tishlang_eval.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectData, PropMap, Value, VmRef};
 
 /// Create a new empty object Value.
@@ -16,6 +20,7 @@ pub fn with_capacity(capacity: usize) -> Value {
     Value::Object(VmRef::new(ObjectData {
         strings: PropMap::with_capacity(capacity),
         symbols: None,
+        frozen: false,
     }))
 }
 

package/crates/tish_builtins/src/string.rs

@@ -3,11 +3,17 @@
 //! All indices use character (Unicode scalar) positions for consistency with
 //! JavaScript, matching .length and .charAt(). Byte offsets are never exposed.
 
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+
 use crate::helpers::normalize_index;
-use std::cell::RefCell;
+use core::cell::RefCell;
 use tishlang_core::ArcStr;
 use tishlang_core::Value;
 use tishlang_core::VmRef;
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
 
 // #203: a per-thread cursor cache that makes repeated character indexing (`charCodeAt(i)`, `s[i]`,
 // `charAt(i)`) O(1)/near-O(1) instead of O(i). tish strings are UTF-8, so `chars().nth(i)` scans from
@@ -29,9 +35,14 @@ struct CharCursor {
     byte_off: usize,
 }
 
+#[cfg(not(feature = "portable"))]
 thread_local! {
     static INDEX_CURSOR: RefCell<Option<CharCursor>> = const { RefCell::new(None) };
 }
+// Single-core: one shared cursor cache with the same `.with()` API.
+#[cfg(feature = "portable")]
+static INDEX_CURSOR: tishlang_core::SingleCore<RefCell<Option<CharCursor>>> =
+    tishlang_core::SingleCore::new(RefCell::new(None));
 
 /// Borrow the cursor entry for `s`, reseeding (compute ASCII flag + character count) if it currently
 /// caches a different backing allocation, then run `f` against it. Centralises the pointer-keyed
@@ -40,7 +51,7 @@ fn with_cursor<R>(s: &ArcStr, f: impl FnOnce(&mut CharCursor, &ArcStr) -> R) ->
     INDEX_CURSOR.with(|cell| {
         let mut slot = cell.borrow_mut();
         let hit = matches!(slot.as_ref(), Some(c)
-            if std::ptr::eq(c.s.as_bytes().as_ptr(), s.as_bytes().as_ptr()) && c.s.len() == s.len());
+            if core::ptr::eq(c.s.as_bytes().as_ptr(), s.as_bytes().as_ptr()) && c.s.len() == s.len());
         if !hit {
             let ascii = s.as_bytes().is_ascii();
             // ASCII → character count equals byte length (free); otherwise count once.

package/crates/tish_builtins/src/symbol.rs

@@ -1,30 +1,30 @@
 //! ECMAScript-style `Symbol`, `Symbol.for`, `Symbol.keyFor`.
 
-use std::collections::hash_map::Entry;
-use std::sync::{Arc, Mutex, OnceLock};
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
 
-use std::collections::HashMap;
+use tishlang_core::sync::{Mutex, OnceLock};
+use tishlang_core::{alloc_symbol_id, AHashMap, Arc, ObjectMap, TishSymbol, Value};
 
-use tishlang_core::{alloc_symbol_id, ObjectMap, TishSymbol, Value};
+static SYMBOL_FOR_REGISTRY: OnceLock<Mutex<AHashMap<Arc<str>, Arc<TishSymbol>>>> = OnceLock::new();
 
-static SYMBOL_FOR_REGISTRY: OnceLock<Mutex<HashMap<Arc<str>, Arc<TishSymbol>>>> = OnceLock::new();
-
-fn symbol_registry() -> &'static Mutex<HashMap<Arc<str>, Arc<TishSymbol>>> {
-    SYMBOL_FOR_REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
+fn symbol_registry() -> &'static Mutex<AHashMap<Arc<str>, Arc<TishSymbol>>> {
+    SYMBOL_FOR_REGISTRY.get_or_init(|| Mutex::new(AHashMap::default()))
 }
 
 fn symbol_for_impl(key: &str) -> Value {
     let k: Arc<str> = key.into();
     let mut reg = symbol_registry().lock().unwrap();
-    let sym = match reg.entry(Arc::clone(&k)) {
-        Entry::Occupied(e) => e.get().clone(),
-        Entry::Vacant(v) => {
-            let id = alloc_symbol_id();
-            let sym = TishSymbol::new_registry(id, Arc::clone(&k), None);
-            v.insert(Arc::clone(&sym));
-            sym
-        }
-    };
+    // get-then-insert (rather than the `Entry` API) so this compiles against both
+    // std `HashMap` and the portable `hashbrown` map without a hasher-specific
+    // `Entry` import. `Symbol.for` is not a hot path.
+    if let Some(existing) = reg.get(&k) {
+        return Value::Symbol(existing.clone());
+    }
+    let id = alloc_symbol_id();
+    let sym = TishSymbol::new_registry(id, Arc::clone(&k), None);
+    reg.insert(k, Arc::clone(&sym));
     Value::Symbol(sym)
 }
 

package/crates/tish_builtins/src/typedarrays.rs

@@ -17,7 +17,13 @@
 //! - A typed array is a regular array at runtime, so `Array.isArray(ta)` is `true` and there is no
 //!   `instanceof` distinction.
 
-use std::sync::Arc;
+#[cfg(feature = "portable")]
+#[allow(unused_imports)]
+use alloc::{borrow::ToOwned, boxed::Box, format, string::{String, ToString}, vec, vec::Vec};
+#[cfg(feature = "portable")]
+use tishlang_core::FloatExt;
+
+use tishlang_core::Arc;
 use tishlang_core::{ObjectMap, Value, VmRef};
 
 const CONSTRUCT: &str = "__construct";
@@ -93,7 +99,7 @@ fn bytes_per_element(kind: Kind) -> f64 {
 fn elements(value: &Value) -> Vec<Value> {
     match value {
         Value::Array(a) => a.borrow().clone(),
-        Value::NumberArray(a) => a.borrow().iter().map(|n| Value::Number(*n)).collect(),
+        Value::NumberArray(a) => a.borrow().to_values(),
         _ => Vec::new(),
     }
 }
@@ -291,6 +297,7 @@ mod tests {
         match &packed {
             Value::NumberArray(a) => {
                 let v = a.borrow();
+                let v = v.as_packed().expect("packed backing");
                 assert_eq!(v[0], 1.1);
                 assert_eq!(v[1], 2.2);
                 assert!(v[2].is_nan());

package/crates/tish_bytecode/src/compiler.rs

@@ -11,7 +11,7 @@ use tishlang_ast::{
 
 use crate::chunk::{Chunk, Constant};
 use crate::encoding::{binop_to_u8, compound_op_to_u8, unaryop_to_u8};
-use crate::opcode::{MathUnaryFn, Opcode};
+use crate::opcode::{MathBinaryFn, MathUnaryFn, Opcode};
 
 enum SimpleMapResult {
     Identity,
@@ -452,6 +452,23 @@ fn expr_rebinds(e: &Expr, name: &str) -> bool {
 /// so it can't run program-wide), this has an explicit `FunDecl` arm: a `function name` is itself a
 /// binding, and every function body is recursed into. `true` (or any node it can't analyze) ⇒ NOT
 /// stable — which only forgoes the cross-function-call optimization, never risks a miscompile.
+/// #203: the f64 value of a `Math.<name>` constant, or `None` if `name` isn't one. The values are the
+/// IEEE doubles ECMAScript specifies (identical to Rust's `std::f64::consts` and to the `Math` object
+/// built on every backend, #539), so emitting them as a `LoadConst` is byte-identical to `Math.PI` etc.
+fn math_constant(name: &str) -> Option<f64> {
+    Some(match name {
+        "PI" => std::f64::consts::PI,
+        "E" => std::f64::consts::E,
+        "LN2" => std::f64::consts::LN_2,
+        "LN10" => std::f64::consts::LN_10,
+        "LOG2E" => std::f64::consts::LOG2_E,
+        "LOG10E" => std::f64::consts::LOG10_E,
+        "SQRT2" => std::f64::consts::SQRT_2,
+        "SQRT1_2" => std::f64::consts::FRAC_1_SQRT_2,
+        _ => return None,
+    })
+}
+
 fn name_rebinds_in_stmt(s: &Statement, name: &str) -> bool {
     match s {
         Statement::FunDecl {
@@ -1968,6 +1985,9 @@ impl<'a> Compiler<'a> {
                 }
                 let mut inner_comp = Compiler::new(&mut inner, false);
                 inner_comp.stable_globals = Arc::clone(&self.stable_globals);
+                // #203: `Math` unshadowed is a whole-program property; thread it so `Math.<fn>` in this
+                // function body lowers to the MathUnary intrinsic (else the numeric JIT bails).
+                inner_comp.math_is_global = self.math_is_global;
                 // Recursion-JIT enabler: if `name`'s binding is provably stable in the body (no
                 // param shadows it, no reassignment/redeclaration), direct `name(args)` calls inside
                 // compile to `SelfCall` — no name lookup, and the numeric JIT lowers it to a native
@@ -2399,6 +2419,31 @@ impl<'a> Compiler<'a> {
                         }
                     }
                 }
+                // #203: `Math.<binfn>(a, b)` → `<a>; <b>; MathBinary(id)` — the same unshadowed-global
+                // gate, for exactly two positional args (variadic `Math.max(a,b,c)` falls through to a
+                // generic call). Lets the numeric JIT lower clamp/pow kernels instead of bailing.
+                if self.math_is_global && args.len() == 2 {
+                    if let Expr::Member {
+                        object,
+                        prop: MemberProp::Name { name: fname, .. },
+                        optional: false,
+                        ..
+                    } = callee.as_ref()
+                    {
+                        if let (Expr::Ident { name: obj, .. }, CallArg::Expr(a0), CallArg::Expr(a1)) =
+                            (object.as_ref(), &args[0], &args[1])
+                        {
+                            if obj.as_ref() == "Math" && self.resolve_slot("Math").is_none() {
+                                if let Some(bfn) = MathBinaryFn::from_name(fname.as_ref()) {
+                                    self.compile_expr(a0)?;
+                                    self.compile_expr(a1)?;
+                                    self.emit_u16(Opcode::MathBinary, bfn as u16);
+                                    return Ok(());
+                                }
+                            }
+                        }
+                    }
+                }
                 // Fast path: arr.sort((a,b)=>a-b) or arr.sort((a,b)=>b-a) -> ArraySortNumeric
                 if !args.iter().any(|a| matches!(a, CallArg::Spread(_)))
                     && args.len() == 1
@@ -2520,6 +2565,26 @@ impl<'a> Compiler<'a> {
                 optional,
                 ..
             } => {
+                // #203: `Math.<CONST>` (PI / E / LN2 / …) when `Math` is the provably-unshadowed
+                // global → a plain `LoadConst`, so the numeric JIT sees a constant instead of bailing
+                // on a `GetMember`. The values match the `Math` object's on every backend (both use
+                // `std::f64::consts`, #539), so this is byte-identical. Same gate as the intrinsics.
+                if !*optional && self.math_is_global {
+                    if let (
+                        Expr::Ident { name: obj, .. },
+                        MemberProp::Name { name: p, .. },
+                    ) = (object.as_ref(), prop)
+                    {
+                        if obj.as_ref() == "Math" && self.resolve_slot("Math").is_none() {
+                            if let Some(v) = math_constant(p.as_ref()) {
+                                let idx = self.constant_idx(Constant::Number(v));
+                                self.emit(Opcode::LoadConst);
+                                self.chunk.write_u16(idx);
+                                return Ok(());
+                            }
+                        }
+                    }
+                }
                 self.compile_expr(object)?;
                 if *optional {
                     self.emit(Opcode::Dup);
@@ -2686,6 +2751,7 @@ impl<'a> Compiler<'a> {
                 }
                 let mut inner_comp = Compiler::new(&mut inner, false);
                 inner_comp.stable_globals = Arc::clone(&self.stable_globals); // #187
+                inner_comp.math_is_global = self.math_is_global; // #203 (see other call site)
                 if let Some(map) = simple_slots {
                     inner_comp.slot_ctx = Some(map);
                 } else {
@@ -3116,7 +3182,15 @@ fn compile_internal(
     // #186 — `Math` intrinsics are sound only if `Math` is never rebound anywhere in the program.
     // `stmt_rebinds` is conservative (any rebind, destructure, FunDecl, or unknown node → true), so a
     // `false` here only forgoes the optimization, never risks a miscompile.
-    compiler.math_is_global = !program.statements.iter().any(|s| stmt_rebinds(s, "Math"));
+    // #203: whole-program scan (recurses into function bodies/params, unlike `stmt_rebinds` which is
+    // conservatively `true` on any FunDecl) — so `Math` is provably-global even when the program
+    // defines functions, letting `Math.<fn>` inside a function lower to the MathUnary intrinsic (the
+    // numeric/array JIT then compiles the kernel instead of bailing on a generic call). Errs toward
+    // "rebound" ⇒ never falsely global ⇒ no miscompile. Threaded into nested compilers below.
+    compiler.math_is_global = !program
+        .statements
+        .iter()
+        .any(|s| name_rebinds_in_stmt(s, "Math"));
     // #187 — the set of top-level functions safe to call directly from JIT'd code (never reassigned/
     // shadowed/redeclared anywhere). Conservative: a name absent here only forgoes the optimization.
     compiler.stable_globals = Arc::new(compute_stable_globals(program));

package/crates/tish_bytecode/src/lib.rs

@@ -16,5 +16,5 @@ pub use compiler::{
     compile_with_source, CompileError,
 };
 pub use encoding::{binop_to_u8, compound_op_to_u8, u8_to_binop, u8_to_unaryop, unaryop_to_u8};
-pub use opcode::{MathUnaryFn, Opcode};
+pub use opcode::{MathBinaryFn, MathUnaryFn, Opcode};
 pub use serialize::{deserialize, serialize};

package/crates/tish_bytecode/src/opcode.rs

@@ -145,6 +145,11 @@ pub enum Opcode {
     /// lower it to a native op / libcall without a runtime shape guard. Behaviour is identical to
     /// `LoadVar Math; GetMember fn; <arg>; Call 1` on a number.
     MathUnary = 55,
+    /// #203 — apply a BINARY `Math.<fn>` intrinsic (max / min / pow / atan2 / hypot) to the top TWO
+    /// numbers: pop `b`, pop `a`, push `Math.fn(a, b)`. The u16 operand is the [`MathBinaryFn`] id.
+    /// Same emission gate as [`Opcode::MathUnary`] (`Math` provably the unshadowed global) but for
+    /// exactly two args. Behaviour identical to `LoadVar Math; GetMember fn; <a>; <b>; Call 2`.
+    MathBinary = 56,
 }
 
 /// The unary `Math` functions the [`Opcode::MathUnary`] fast path recognizes (#186). f64→f64;
@@ -289,11 +294,81 @@ impl MathUnaryFn {
     }
 }
 
+/// The binary `Math` functions the [`Opcode::MathBinary`] fast path recognizes (#203). `(f64, f64) →
+/// f64`; the discriminant is the opcode operand. Kept in sync with the VM handler and JIT lowering.
+/// (`hypot` is intentionally NOT here — it stays a correct generic call to avoid replicating its
+/// scaled-sum-of-squares in this below-builtins crate.)
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u16)]
+pub enum MathBinaryFn {
+    Max = 0,
+    Min = 1,
+    Pow = 2,
+    Atan2 = 3,
+}
+
+impl MathBinaryFn {
+    /// Map a `Math.<name>` member to its id, or `None` if it isn't a supported 2-arg intrinsic.
+    pub fn from_name(name: &str) -> Option<MathBinaryFn> {
+        Some(match name {
+            "max" => MathBinaryFn::Max,
+            "min" => MathBinaryFn::Min,
+            "pow" => MathBinaryFn::Pow,
+            "atan2" => MathBinaryFn::Atan2,
+            _ => return None,
+        })
+    }
+
+    /// Decode an opcode operand to the fn id (safe match — no transmute).
+    pub fn from_u16(v: u16) -> Option<MathBinaryFn> {
+        use MathBinaryFn::*;
+        Some(match v {
+            0 => Max,
+            1 => Min,
+            2 => Pow,
+            3 => Atan2,
+            _ => return None,
+        })
+    }
+
+    /// Apply the intrinsic — the single source of truth for VM + JIT result parity. Replicates the JS
+    /// semantics of `tishlang_builtins::math` (this crate sits below builtins), so VM/JIT == interp.
+    #[inline]
+    pub fn apply(self, a: f64, b: f64) -> f64 {
+        match self {
+            // Math.max(a,b): NaN if either is NaN; else the larger, with +0 preferred over -0. Exactly
+            // `max_f64(&[a, b])`.
+            MathBinaryFn::Max => {
+                if a.is_nan() || b.is_nan() {
+                    f64::NAN
+                } else if a > b || (a == 0.0 && b == 0.0 && a.is_sign_positive()) {
+                    a
+                } else {
+                    b
+                }
+            }
+            // Math.min(a,b): NaN if either is NaN; else the smaller, with -0 preferred. Exactly
+            // `min_f64(&[a, b])`.
+            MathBinaryFn::Min => {
+                if a.is_nan() || b.is_nan() {
+                    f64::NAN
+                } else if a < b || (a == 0.0 && b == 0.0 && a.is_sign_negative()) {
+                    a
+                } else {
+                    b
+                }
+            }
+            MathBinaryFn::Pow => a.powf(b),
+            MathBinaryFn::Atan2 => a.atan2(b),
+        }
+    }
+}
+
 impl Opcode {
-    /// Decode byte to opcode. Safe for b in 0..=55 (matches #[repr(u8)] discriminants).
+    /// Decode byte to opcode. Safe for b in 0..=56 (matches #[repr(u8)] discriminants).
     #[inline]
     pub fn from_u8(b: u8) -> Option<Opcode> {
-        if b <= 55 {
+        if b <= 56 {
             Some(unsafe { std::mem::transmute::<u8, Opcode>(b) })
         } else {
             None