@tishlang/tish 2.2.7 → 2.9.0

package/crates/tish_builtins/src/string.rs

@@ -215,15 +215,39 @@ pub fn substr(s: &Value, start: &Value, length: &Value) -> Value {
 }
 
 pub fn split(s: &Value, sep: &Value) -> Value {
+    split_limit(s, sep, None)
+}
+
+/// `String.prototype.split(sep, limit)` for a string separator. JS semantics: the string is split
+/// completely on `sep`, then the result is truncated to `limit` elements (it does NOT keep the
+/// unsplit remainder in the last slot, which is what Rust's `splitn` would do). `limit == 0` yields
+/// an empty array. This is the single source of truth shared by the VM and rust/cranelift/wasi
+/// backends; the interpreter mirrors it in `tish_eval::regex::string_split`.
+pub fn split_limit(s: &Value, sep: &Value, limit: Option<usize>) -> Value {
     if let Value::String(s) = s {
         let separator = match sep {
             Value::String(ss) => ss.as_str(),
             _ => return Value::Array(VmRef::new(vec![Value::String(s.clone())])),
         };
-        let parts: Vec<Value> = s
-            .split(separator)
-            .map(|p| Value::String(p.into()))
-            .collect();
+        if limit == Some(0) {
+            return Value::Array(VmRef::new(Vec::new()));
+        }
+        // JS `split("")` is special: it yields the string's characters with NO surrounding empties
+        // (`"xyz".split("")` → `["x","y","z"]`, `"".split("")` → `[]`), unlike Rust's `str::split("")`
+        // which emits leading/trailing `""`. (tish splits on `char`s; lone-surrogate behavior for
+        // astral code points is out of scope.) #247
+        if separator.is_empty() {
+            let mut parts: Vec<Value> =
+                s.chars().map(|c| Value::String(c.to_string().into())).collect();
+            if let Some(max) = limit {
+                parts.truncate(max);
+            }
+            return Value::Array(VmRef::new(parts));
+        }
+        let mut parts: Vec<Value> = s.split(separator).map(|p| Value::String(p.into())).collect();
+        if let Some(max) = limit {
+            parts.truncate(max);
+        }
         Value::Array(VmRef::new(parts))
     } else {
         Value::Null
@@ -364,6 +388,24 @@ pub fn char_at(s: &Value, idx: &Value) -> Value {
     }
 }
 
+/// `String.prototype.at(index)` — like `charAt` but negative `index` counts from the end and an
+/// out-of-range index yields `null` (JS `undefined`), not `""`. #247
+pub fn at(s: &Value, index: &Value) -> Value {
+    if let Value::String(s) = s {
+        let i = match index {
+            Value::Number(n) => *n as i64,
+            _ => 0,
+        };
+        let chars: Vec<char> = s.chars().collect();
+        let len = chars.len() as i64;
+        let idx = if i < 0 { len + i } else { i };
+        if idx >= 0 && idx < len {
+            return Value::String(chars[idx as usize].to_string().into());
+        }
+    }
+    Value::Null
+}
+
 pub fn char_code_at(s: &Value, idx: &Value) -> Value {
     if let Value::String(s) = s {
         let idx = match idx {
@@ -541,6 +583,28 @@ mod tests {
         assert_same!(trim(&n(1.0)), Value::Null);
     }
 
+    #[test]
+    fn split_limit_js_semantics() {
+        let parts = |v: &Value| -> Vec<String> {
+            let Value::Array(a) = v else { panic!("not array") };
+            a.borrow()
+                .iter()
+                .map(|x| match x {
+                    Value::String(s) => s.to_string(),
+                    _ => panic!("not string"),
+                })
+                .collect()
+        };
+        // limit truncates to the first N pieces (does NOT keep the remainder, unlike `splitn`)
+        assert_eq!(parts(&split_limit(&s("a,b,c,d"), &s(","), Some(2))), ["a", "b"]);
+        // limit 0 -> empty; limit beyond piece count -> full split; no limit -> full split
+        assert_eq!(parts(&split_limit(&s("a,b,c,d"), &s(","), Some(0))).len(), 0);
+        assert_eq!(parts(&split_limit(&s("a,b,c,d"), &s(","), Some(10))), ["a", "b", "c", "d"]);
+        assert_eq!(parts(&split_limit(&s("a,b,c,d"), &s(","), None)), ["a", "b", "c", "d"]);
+        // split() delegates with no limit
+        assert_eq!(parts(&split(&s("one two"), &s(" "))), ["one", "two"]);
+    }
+
     #[test]
     fn case_and_prefix_suffix() {
         assert_same!(to_upper_case(&s("aB")), s("AB"));

package/crates/tish_builtins/src/typedarrays.rs

@@ -136,7 +136,14 @@ fn construct(kind: Kind, args: &[Value]) -> Value {
 /// construction-only-coercion gap for this one view). Any op without a packed fast path materialises
 /// it back to a boxed array, so every array method keeps working.
 pub fn float64_array_packed(args: &[Value]) -> Value {
-    if !Value::packed_arrays_enabled() {
+    float64_array_with(Value::packed_arrays_enabled(), args)
+}
+
+/// `float64_array_packed` with the packed/boxed choice made explicit, so tests exercise both paths
+/// without toggling the now-cached process env flag (#166). `packed = false` is byte-identical to
+/// the generic boxed `Value::Array` constructor.
+fn float64_array_with(packed: bool, args: &[Value]) -> Value {
+    if !packed {
         // Byte-identical fallback to the generic boxed `Value::Array` backing.
         return construct(Kind::F64, args);
     }
@@ -261,25 +268,26 @@ mod tests {
         assert_eq!(nums(&v), vec![0.0, 1.0]);
     }
 
-    // `float64_array_packed` toggles on a process-global env var. No other test in this crate reads
-    // `packed_arrays_enabled`, so the set/remove here can't perturb a concurrent test; we restore the
-    // default (off) on exit regardless.
+    // The packed/boxed selection is passed explicitly via `float64_array_with`, so this exercises
+    // both paths without touching the now-cached process env flag (#166) — no env mutation, no
+    // mid-test toggle race, parallel-safe.
     #[test]
     fn float64_packed_respects_flag() {
-        // Flag off (default): byte-identical boxed `Value::Array` fallback, no packed value produced.
-        std::env::remove_var("TISH_PACKED_ARRAYS");
-        let boxed = float64_array_packed(&[Value::Number(3.0)]);
+        // Packed off (the default): byte-identical boxed `Value::Array` fallback.
+        let boxed = float64_array_with(false, &[Value::Number(3.0)]);
         assert!(matches!(boxed, Value::Array(_)), "packed-off must return boxed Array");
         assert_eq!(nums(&boxed), vec![0.0, 0.0, 0.0]);
 
-        // Flag on: packed `Value::NumberArray`. F64 needs no coercion (exact), non-numeric → NaN
+        // Packed on: `Value::NumberArray`. F64 needs no coercion (exact), non-numeric → NaN
         // (matching the boxed `from_values(F64, …)`), and the length form zero-fills.
-        std::env::set_var("TISH_PACKED_ARRAYS", "1");
-        let packed = float64_array_packed(&[Value::Array(VmRef::new(vec![
-            Value::Number(1.1),
-            Value::Number(2.2),
-            Value::Null,
-        ]))]);
+        let packed = float64_array_with(
+            true,
+            &[Value::Array(VmRef::new(vec![
+                Value::Number(1.1),
+                Value::Number(2.2),
+                Value::Null,
+            ]))],
+        );
         match &packed {
             Value::NumberArray(a) => {
                 let v = a.borrow();
@@ -290,9 +298,8 @@ mod tests {
             _ => panic!("packed-on must return NumberArray"),
         }
         assert!(matches!(
-            float64_array_packed(&[Value::Number(2.0)]),
+            float64_array_with(true, &[Value::Number(2.0)]),
             Value::NumberArray(_)
         ));
-        std::env::remove_var("TISH_PACKED_ARRAYS");
     }
 }

package/crates/tish_bytecode/src/compiler.rs

@@ -157,7 +157,7 @@ fn expr_is_param_only(e: &Expr, params: &HashSet<&str>) -> bool {
             ArrayElement::Spread(_) => false,
         }),
         Expr::Object { props, .. } => props.iter().all(|p| match p {
-            ObjectProp::KeyValue(_, x) => expr_is_param_only(x, params),
+            ObjectProp::KeyValue(_, x, _) => expr_is_param_only(x, params),
             ObjectProp::Spread(_) => false,
         }),
         Expr::TemplateLiteral { exprs, .. } => {
@@ -332,7 +332,7 @@ fn expr_rebinds(e: &Expr, name: &str) -> bool {
             ArrayElement::Expr(e) | ArrayElement::Spread(e) => expr_rebinds(e, name),
         }),
         Expr::Object { props, .. } => props.iter().any(|p| match p {
-            ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => expr_rebinds(e, name),
+            ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => expr_rebinds(e, name),
         }),
         Expr::MemberAssign { object, value, .. } => expr_rebinds(object, name) || expr_rebinds(value, name),
         Expr::IndexAssign { object, index, value, .. } => {
@@ -452,7 +452,7 @@ impl SlotScan {
                 ArrayElement::Expr(e) | ArrayElement::Spread(e) => self.expr(e, in_closure),
             }),
             Expr::Object { props, .. } => props.iter().all(|p| match p {
-                ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => self.expr(e, in_closure),
+                ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => self.expr(e, in_closure),
             }),
             Expr::Assign { name, value, .. }
             | Expr::CompoundAssign { name, value, .. }
@@ -836,6 +836,53 @@ impl<'a> Compiler<'a> {
         self.chunk.code[patch_pos + 1] = bytes[1];
     }
 
+    /// Compile `cond` in CONDITION position (if / while / for / do-while). The operand stack is EMPTY
+    /// at every emitted `JumpIfFalse` — `&&` / `||` lower to pure control flow rather than the
+    /// value-producing `Dup` + `BinOp` form, so a hot numeric loop whose only disqualifier was the
+    /// condition shape stays eligible for the cranelift JIT (#167). Returns the `JumpIfFalse` patch
+    /// sites the caller must point at its "condition is false" target. The condition value itself is
+    /// never observed here, so truthiness-only lowering is exact; short-circuit order is preserved.
+    fn compile_condition_jump_if_false(
+        &mut self,
+        cond: &Expr,
+    ) -> Result<Vec<usize>, CompileError> {
+        match cond {
+            // `a && b` is false if EITHER operand is false — test each in order; both exit to the
+            // same false-target, so concatenate their patch sites.
+            Expr::Binary {
+                left,
+                op: BinOp::And,
+                right,
+                ..
+            } => {
+                let mut patches = self.compile_condition_jump_if_false(left)?;
+                patches.extend(self.compile_condition_jump_if_false(right)?);
+                Ok(patches)
+            }
+            // `a || b`: a truthy left makes the condition hold (skip the right); only the right's
+            // falsiness exits.
+            Expr::Binary {
+                left,
+                op: BinOp::Or,
+                right,
+                ..
+            } => {
+                self.compile_expr(left)?;
+                let take_right = self.emit_jump(Opcode::JumpIfFalse); // left falsy → evaluate right
+                let done = self.emit_jump(Opcode::Jump); // left truthy → condition holds
+                self.patch_jump(take_right, self.chunk.code.len());
+                let patches = self.compile_condition_jump_if_false(right)?;
+                self.patch_jump(done, self.chunk.code.len());
+                Ok(patches)
+            }
+            // Any other expression: evaluate it; one JumpIfFalse consumes the value.
+            _ => {
+                self.compile_expr(cond)?;
+                Ok(vec![self.emit_jump(Opcode::JumpIfFalse)])
+            }
+        }
+    }
+
     /// Patch a JumpBack operand: distance from the IP after this insn back to `target`.
     /// `patch_pos` is the first byte of the u16 operand (same as [`Self::emit_jump_back`]'s return value).
     fn patch_jump_back(&mut self, patch_pos: usize, target: usize) {
@@ -1194,11 +1241,13 @@ impl<'a> Compiler<'a> {
                 else_branch,
                 ..
             } => {
-                self.compile_expr(cond)?;
-                let jump_else = self.emit_jump(Opcode::JumpIfFalse);
+                let jump_else_sites = self.compile_condition_jump_if_false(cond)?;
                 self.compile_statement(then_branch)?;
                 let jump_end = self.emit_jump(Opcode::Jump);
-                self.patch_jump(jump_else, self.chunk.code.len());
+                let else_target = self.chunk.code.len();
+                for site in &jump_else_sites {
+                    self.patch_jump(*site, else_target);
+                }
                 if let Some(else_s) = else_branch {
                     self.compile_statement(else_s)?;
                 }
@@ -1222,14 +1271,16 @@ impl<'a> Compiler<'a> {
                 self.breakable_stack.push(Breakable::Loop {
                     unwind_depth: self.block_depth,
                 });
-                self.compile_expr(cond)?;
-                let jump_out = self.emit_jump(Opcode::JumpIfFalse);
-                // JumpIfFalse already pops condition when taking body
+                // Condition-position lowering: empty stack at each JumpIfFalse keeps the loop
+                // JIT-eligible (#167). Each returned site exits to `end`.
+                let jump_out_sites = self.compile_condition_jump_if_false(cond)?;
                 self.compile_statement(body)?;
                 let jump_back_dist = (self.chunk.code.len() + 3).saturating_sub(start);
                 self.emit_u16(Opcode::JumpBack, jump_back_dist as u16);
                 let end = self.chunk.code.len();
-                self.patch_jump(jump_out, end);
+                for site in &jump_out_sites {
+                    self.patch_jump(*site, end);
+                }
                 let info = self.loop_stack.pop().unwrap();
                 self.breakable_stack.pop();
                 for p in info.continue_patches {
@@ -1266,14 +1317,16 @@ impl<'a> Compiler<'a> {
                     self.emit_u16(Opcode::LoopVarsBegin, idx);
                 }
                 let cond_start = self.chunk.code.len();
-                if let Some(c) = cond {
-                    self.compile_expr(c)?;
+                // Condition-position lowering keeps the loop JIT-eligible (#167). The absent-condition
+                // `for (;;)` keeps its `true` constant + single exit jump.
+                let jump_out_sites = if let Some(c) = cond {
+                    self.compile_condition_jump_if_false(c)?
                 } else {
                     let idx = self.constant_idx(Constant::Bool(true));
                     self.emit(Opcode::LoadConst);
                     self.chunk.write_u16(idx);
-                }
-                let jump_out = self.emit_jump(Opcode::JumpIfFalse);
+                    vec![self.emit_jump(Opcode::JumpIfFalse)]
+                };
                 self.loop_stack.push(LoopInfo {
                     break_patches: Vec::new(),
                     continue_patches: Vec::new(),
@@ -1295,7 +1348,9 @@ impl<'a> Compiler<'a> {
                 let jump_back_dist = (self.chunk.code.len() + 3).saturating_sub(cond_start);
                 self.emit_u16(Opcode::JumpBack, jump_back_dist as u16);
                 let end = self.chunk.code.len();
-                self.patch_jump(jump_out, end);
+                for site in &jump_out_sites {
+                    self.patch_jump(*site, end);
+                }
                 for p in info.break_patches {
                     self.patch_jump(p, end);
                 }
@@ -1561,23 +1616,32 @@ impl<'a> Compiler<'a> {
                 self.loop_stack.push(LoopInfo {
                     break_patches: Vec::new(),
                     continue_patches: Vec::new(),
-                    continue_is_forward_jump: false,
+                    // `continue` jumps to the condition test, which is emitted AFTER the body — a
+                    // FORWARD jump. (A backward JumpBack would patch to dist = 0 via saturating_sub
+                    // of a forward target, becoming a no-op; execution then fell through and re-ran
+                    // the body's already-unwound ExitBlock on an empty block stack — the
+                    // "ExitBlock without matching EnterBlock" crash.)
+                    continue_is_forward_jump: true,
                 });
                 self.breakable_stack.push(Breakable::Loop {
                     unwind_depth: self.block_depth,
                 });
                 self.compile_statement(body)?;
                 let cond_start = self.chunk.code.len();
-                self.compile_expr(cond)?;
-                let jump_back = self.emit_jump(Opcode::JumpIfFalse);
+                // Condition-position lowering: a false condition exits to `end`, a true one falls
+                // through to the JumpBack — JIT-eligible, no value left on the stack (#167).
+                let exit_sites = self.compile_condition_jump_if_false(cond)?;
                 let jump_back_dist = (self.chunk.code.len() + 3).saturating_sub(start);
                 self.emit_u16(Opcode::JumpBack, jump_back_dist as u16);
                 let end = self.chunk.code.len();
-                self.patch_jump(jump_back, end);
+                for site in &exit_sites {
+                    self.patch_jump(*site, end);
+                }
                 let info = self.loop_stack.pop().unwrap();
                 self.breakable_stack.pop();
                 for p in info.continue_patches {
-                    self.patch_jump_back(p, cond_start);
+                    // Forward jump to the condition (see continue_is_forward_jump above).
+                    self.patch_jump(p, cond_start);
                 }
                 for p in info.break_patches {
                     self.patch_jump(p, end);
@@ -1859,14 +1923,16 @@ impl<'a> Compiler<'a> {
             } => {
                 match op {
                     BinOp::And => {
-                        // Short-circuit: a && b => if !a then a else b
+                        // Short-circuit + value-returning (JS): `a && b` is `a` when `a` is falsy,
+                        // else `b` — NOT a coerced boolean (#240). Mirror the `||` lowering below:
+                        // keep the left operand on a falsy short-circuit, discard it and evaluate the
+                        // right otherwise. (The old `BinOp(And)` here coerced a truthy-left result to
+                        // a Bool, so `five() && 7` yielded `true` instead of `7`.)
                         self.compile_expr(left)?;
                         self.emit(Opcode::Dup);
-                        let jump_shortcut = self.emit_jump(Opcode::JumpIfFalse);
-                        self.compile_expr(right)?; // left still on stack from Dup
-                        self.emit_u8(Opcode::BinOp, binop_to_u8(BinOp::And));
-                        let jump_end = self.emit_jump(Opcode::Jump);
-                        self.patch_jump(jump_shortcut, self.chunk.code.len());
+                        let jump_end = self.emit_jump(Opcode::JumpIfFalse); // a falsy → keep a
+                        self.emit(Opcode::Pop); // a truthy → discard a …
+                        self.compile_expr(right)?; // … and yield b
                         self.patch_jump(jump_end, self.chunk.code.len());
                     }
                     BinOp::Or => {
@@ -2123,7 +2189,7 @@ impl<'a> Compiler<'a> {
                     self.emit_u16(Opcode::NewObject, 0); // start with {}
                     for prop in props {
                         match prop {
-                            ObjectProp::KeyValue(k, v) => {
+                            ObjectProp::KeyValue(k, v, _) => {
                                 let idx = self.constant_idx(Constant::String(Arc::clone(k)));
                                 self.emit(Opcode::LoadConst);
                                 self.chunk.write_u16(idx);
@@ -2139,7 +2205,7 @@ impl<'a> Compiler<'a> {
                     }
                 } else {
                     for prop in props {
-                        if let ObjectProp::KeyValue(k, v) = prop {
+                        if let ObjectProp::KeyValue(k, v, _) = prop {
                             let idx = self.constant_idx(Constant::String(Arc::clone(k)));
                             self.emit(Opcode::LoadConst);
                             self.chunk.write_u16(idx);

package/crates/tish_bytecode/tests/break_continue_bytecode.rs

@@ -42,3 +42,22 @@ fn mutation_vm_ast_opt_with_peephole() {
     let chunk = compile(&prog).expect("compile");
     run(&chunk).expect("VM");
 }
+
+// Regression: `continue` inside a `do { } while (cond)` targets the condition test, which is emitted
+// AFTER the body — a FORWARD jump. It used to be lowered as a backward `JumpBack`, which `patch_jump_back`
+// resolved to distance 0 (saturating_sub of a forward target) — a no-op. Execution then fell through into
+// the body block's already-unwound `ExitBlock`, crashing the VM with "ExitBlock without matching
+// EnterBlock". The `continue` here unwinds the body block AND the `if` then-block, so it exercises the
+// multi-ExitBlock unwind path specifically.
+#[test]
+fn do_while_continue_does_not_crash_vm() {
+    let src = "let d = 0\n\
+               do {\n\
+                 d = d + 1\n\
+                 if (d === 2) { continue }\n\
+               } while (d < 5)\n";
+    let prog = tishlang_parser::parse(src).expect("parse");
+    // Both compile paths must run clean (the crash happened regardless of peephole optimization).
+    run(&compile_unoptimized(&prog).expect("compile (unopt)")).expect("VM run unoptimized");
+    run(&compile(&prog).expect("compile (opt)")).expect("VM run optimized");
+}

package/crates/tish_compile/src/check.rs

@@ -590,7 +590,7 @@ impl CheckCtx {
                 let mut fields = Vec::new();
                 for p in props {
                     match p {
-                        ObjectProp::KeyValue(k, v) => {
+                        ObjectProp::KeyValue(k, v, _) => {
                             let t = self.synth(v)?;
                             fields.push((k.clone(), t));
                         }