@tishlang/tish 2.10.1 → 2.16.13

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::Opcode;
+pub use opcode::{MathUnaryFn, Opcode};
 pub use serialize::{deserialize, serialize};

package/crates/tish_bytecode/src/opcode.rs

@@ -133,13 +133,165 @@ pub enum Opcode {
     /// `delete obj[key]` / `delete obj.prop`. Pops `[obj, key]`, removes the property
     /// (objects: drop the key; arrays: set the index to a null hole), pushes `true`.
     DeleteIndex = 53,
+    /// String-builder append for statement-position `acc += rhs` where `acc` is a frame slot local
+    /// (operand: u16 slot index). Pops `rhs`; appends it to the accumulator in amortized O(1) by
+    /// keeping a growable buffer for the slot (see the frame-local builder in `run_chunk`). Leaves
+    /// nothing on the stack — only emitted where the assignment's result is discarded. Slots are
+    /// frame-private (never captured), so the buffer needs no cross-frame sharing.
+    AppendLocal = 54,
+    /// #186 — apply a unary `Math.<fn>` intrinsic to the top-of-stack number: pop one value, push
+    /// `Math.fn(x)`. The u16 operand is the [`MathUnaryFn`] id. Emitted by the compiler ONLY when
+    /// `Math` is provably the global builtin (never shadowed in the program), so the numeric JIT can
+    /// 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,
+}
+
+/// The unary `Math` functions the [`Opcode::MathUnary`] fast path recognizes (#186). f64→f64;
+/// the discriminant is the opcode operand. Kept in sync with the VM handler and the JIT lowering.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u16)]
+pub enum MathUnaryFn {
+    Sqrt = 0,
+    Cbrt = 1,
+    Abs = 2,
+    Floor = 3,
+    Ceil = 4,
+    Round = 5,
+    Trunc = 6,
+    Sign = 7,
+    Sin = 8,
+    Cos = 9,
+    Tan = 10,
+    Asin = 11,
+    Acos = 12,
+    Atan = 13,
+    Sinh = 14,
+    Cosh = 15,
+    Tanh = 16,
+    Exp = 17,
+    Log = 18,
+    Log2 = 19,
+    Log10 = 20,
+}
+
+impl MathUnaryFn {
+    /// Map a `Math.<name>` member to its id, or `None` if it isn't a supported unary intrinsic.
+    pub fn from_name(name: &str) -> Option<MathUnaryFn> {
+        Some(match name {
+            "sqrt" => MathUnaryFn::Sqrt,
+            "cbrt" => MathUnaryFn::Cbrt,
+            "abs" => MathUnaryFn::Abs,
+            "floor" => MathUnaryFn::Floor,
+            "ceil" => MathUnaryFn::Ceil,
+            "round" => MathUnaryFn::Round,
+            "trunc" => MathUnaryFn::Trunc,
+            "sign" => MathUnaryFn::Sign,
+            "sin" => MathUnaryFn::Sin,
+            "cos" => MathUnaryFn::Cos,
+            "tan" => MathUnaryFn::Tan,
+            "asin" => MathUnaryFn::Asin,
+            "acos" => MathUnaryFn::Acos,
+            "atan" => MathUnaryFn::Atan,
+            "sinh" => MathUnaryFn::Sinh,
+            "cosh" => MathUnaryFn::Cosh,
+            "tanh" => MathUnaryFn::Tanh,
+            "exp" => MathUnaryFn::Exp,
+            "log" => MathUnaryFn::Log,
+            "log2" => MathUnaryFn::Log2,
+            "log10" => MathUnaryFn::Log10,
+            _ => return None,
+        })
+    }
+
+    /// Decode an opcode operand to the fn id (safe match — no transmute).
+    pub fn from_u16(v: u16) -> Option<MathUnaryFn> {
+        use MathUnaryFn::*;
+        Some(match v {
+            0 => Sqrt,
+            1 => Cbrt,
+            2 => Abs,
+            3 => Floor,
+            4 => Ceil,
+            5 => Round,
+            6 => Trunc,
+            7 => Sign,
+            8 => Sin,
+            9 => Cos,
+            10 => Tan,
+            11 => Asin,
+            12 => Acos,
+            13 => Atan,
+            14 => Sinh,
+            15 => Cosh,
+            16 => Tanh,
+            17 => Exp,
+            18 => Log,
+            19 => Log2,
+            20 => Log10,
+            _ => return None,
+        })
+    }
+
+    /// Apply the intrinsic (the single source of truth for VM + JIT + interp result parity).
+    #[inline]
+    pub fn apply(self, x: f64) -> f64 {
+        match self {
+            MathUnaryFn::Sqrt => x.sqrt(),
+            MathUnaryFn::Cbrt => x.cbrt(),
+            MathUnaryFn::Abs => x.abs(),
+            MathUnaryFn::Floor => x.floor(),
+            MathUnaryFn::Ceil => x.ceil(),
+            // JS `Math.round`: ties toward +∞, `[-0.5, 0) → -0`; EXACTLY `tishlang_builtins::math::
+            // round_f64` (replicated here — this crate sits below builtins — so VM/JIT == interp).
+            MathUnaryFn::Round => {
+                if x.is_nan() || x.is_infinite() || x == 0.0 {
+                    x
+                } else if (-0.5..0.5).contains(&x) {
+                    if x < 0.0 {
+                        -0.0
+                    } else {
+                        0.0
+                    }
+                } else {
+                    (x + 0.5).floor()
+                }
+            }
+            MathUnaryFn::Trunc => x.trunc(),
+            // JS `Math.sign` (matches `tishlang_builtins::math::sign`): NaN→NaN, else ±1, and 0/-0→+0.
+            MathUnaryFn::Sign => {
+                if x.is_nan() {
+                    f64::NAN
+                } else if x > 0.0 {
+                    1.0
+                } else if x < 0.0 {
+                    -1.0
+                } else {
+                    0.0
+                }
+            }
+            MathUnaryFn::Sin => x.sin(),
+            MathUnaryFn::Cos => x.cos(),
+            MathUnaryFn::Tan => x.tan(),
+            MathUnaryFn::Asin => x.asin(),
+            MathUnaryFn::Acos => x.acos(),
+            MathUnaryFn::Atan => x.atan(),
+            MathUnaryFn::Sinh => x.sinh(),
+            MathUnaryFn::Cosh => x.cosh(),
+            MathUnaryFn::Tanh => x.tanh(),
+            MathUnaryFn::Exp => x.exp(),
+            MathUnaryFn::Log => x.ln(),
+            MathUnaryFn::Log2 => x.log2(),
+            MathUnaryFn::Log10 => x.log10(),
+        }
+    }
 }
 
 impl Opcode {
-    /// Decode byte to opcode. Safe for b in 0..=53 (matches #[repr(u8)] discriminants).
+    /// Decode byte to opcode. Safe for b in 0..=55 (matches #[repr(u8)] discriminants).
     #[inline]
     pub fn from_u8(b: u8) -> Option<Opcode> {
-        if b <= 53 {
+        if b <= 55 {
             Some(unsafe { std::mem::transmute::<u8, Opcode>(b) })
         } else {
             None

package/crates/tish_bytecode/src/serialize.rs

@@ -189,5 +189,7 @@ pub fn deserialize(mut data: &[u8]) -> Result<Chunk, String> {
         // Debug-only; not part of the serialized format (issue #74).
         lines: Vec::new(),
         source: None,
+        // #187: runtime-only — a deserialized program forgoes the cross-function-call optimization.
+        global_name: None,
     })
 }

package/crates/tish_bytecode/tests/append_local_string_builder.rs

@@ -0,0 +1,63 @@
+//! #186 — the plain-assign string-builder fast path: `s = s + <str>` compiles to `AppendLocal`, but a
+//! numeric accumulator `i = i + 1` must NOT (or the VM's single string-builder slot thrashes → O(n²)).
+
+use tishlang_bytecode::{compile, Chunk, Opcode};
+use tishlang_parser::parse;
+
+fn count_opcode(chunk: &Chunk, op: u8) -> usize {
+    // Opcodes are variable-width; the compiler here emits only slot-carrying ops, so a byte-value
+    // scan is a sufficient upper bound for these targeted single-loop programs. We assert presence
+    // vs absence, not exact counts, so an incidental operand collision can't cause a false pass.
+    let mut n = chunk.code.iter().filter(|&&b| b == op).count();
+    for nested in &chunk.nested {
+        n += count_opcode(nested, op);
+    }
+    n
+}
+
+fn chunk_of(src: &str) -> Chunk {
+    let program = parse(src).expect("parse");
+    let optimized = tishlang_opt::optimize(&program);
+    compile(&optimized).expect("compile")
+}
+
+#[test]
+fn string_plus_assign_uses_append_local() {
+    // `s = s + "x"` must route through the builder (the string_concat 55x→2.5x win).
+    let chunk = chunk_of("let s = \"\"\nlet i = 0\nwhile (i < 10) { s = s + \"x\"; i = i + 1 }\n");
+    assert!(
+        count_opcode(&chunk, Opcode::AppendLocal as u8) >= 1,
+        "`s = s + \"x\"` must emit AppendLocal"
+    );
+}
+
+#[test]
+fn numeric_plus_assign_does_not_use_append_local() {
+    // A pure numeric loop must NOT builder-ize — no AppendLocal at all.
+    let chunk = chunk_of("let n = 0\nlet i = 0\nwhile (i < 10) { n = n + 2; i = i + 1 }\n");
+    assert_eq!(
+        count_opcode(&chunk, Opcode::AppendLocal as u8),
+        0,
+        "`n = n + 2` / `i = i + 1` must NOT emit AppendLocal (would thrash the single builder slot)"
+    );
+}
+
+#[test]
+fn template_literal_rhs_uses_append_local() {
+    let chunk = chunk_of("let t = \"\"\nlet j = 0\nwhile (j < 3) { t = t + `[${j}]`; j = j + 1 }\n");
+    assert!(
+        count_opcode(&chunk, Opcode::AppendLocal as u8) >= 1,
+        "`t = t + `[${{j}}]`` (template RHS) must emit AppendLocal"
+    );
+}
+
+#[test]
+fn prepend_does_not_use_append_local() {
+    // `p = "a" + p` is a prepend — the builder appends, so it must NOT match.
+    let chunk = chunk_of("let p = \"z\"\np = \"a\" + p\n");
+    assert_eq!(
+        count_opcode(&chunk, Opcode::AppendLocal as u8),
+        0,
+        "prepend `p = \"a\" + p` must not use the append builder"
+    );
+}

package/crates/tish_bytecode/tests/math_unary_intrinsic.rs

@@ -0,0 +1,47 @@
+//! #186 — `Math.<unaryfn>(arg)` lowers to `MathUnary` ONLY when `Math` is the unshadowed global; a
+//! rebound `Math`, a 2-arg `Math.*`, or a non-math member must keep the general call path.
+
+use tishlang_bytecode::{compile, Chunk, Opcode};
+use tishlang_parser::parse;
+
+fn has_math_unary(chunk: &Chunk) -> bool {
+    if chunk.code.contains(&(Opcode::MathUnary as u8)) {
+        return true;
+    }
+    chunk.nested.iter().any(has_math_unary)
+}
+
+fn chunk_of(src: &str) -> Chunk {
+    let program = parse(src).expect("parse");
+    let optimized = tishlang_opt::optimize(&program);
+    compile(&optimized).expect("compile")
+}
+
+#[test]
+fn global_math_unary_emits_intrinsic() {
+    assert!(has_math_unary(&chunk_of("let x = Math.sqrt(4.0)\n")), "Math.sqrt → MathUnary");
+    assert!(has_math_unary(&chunk_of("let x = Math.sin(1.0) + Math.floor(2.5)\n")));
+}
+
+#[test]
+fn shadowed_math_keeps_general_call() {
+    // `Math` rebound as a local → the intrinsic would be a miscompile; must NOT emit MathUnary.
+    assert!(
+        !has_math_unary(&chunk_of("let Math = 5\nlet x = Math\n")),
+        "a program that rebinds `Math` must not intrinsify"
+    );
+    assert!(
+        !has_math_unary(&chunk_of(
+            "fn mysqrt(x) { return x }\nlet Math = { sqrt: mysqrt }\nlet x = Math.sqrt(4.0)\n"
+        )),
+        "a shadowed Math.sqrt must call the user's method"
+    );
+}
+
+#[test]
+fn non_unary_math_stays_a_call() {
+    // Math.max is 2-arg (not a unary intrinsic) → general call, no MathUnary.
+    assert!(!has_math_unary(&chunk_of("let x = Math.max(1.0, 2.0)\n")), "Math.max is not unary");
+    // Math.PI is a property, not a call.
+    assert!(!has_math_unary(&chunk_of("let x = Math.PI\n")), "Math.PI is a property");
+}