@tishlang/tish 2.2.5 → 2.8.0

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

@@ -29,6 +29,7 @@ fn lit_base(lit: &TypeLiteral) -> TypeAnnotation {
             TypeLiteral::Bool(_) => "boolean",
         }
         .into(),
+        tishlang_ast::Span::default(),
     )
 }
 
@@ -70,19 +71,19 @@ pub fn check_program(program: &Program) -> Vec<TypeDiagnostic> {
 // ── helpers: type constructors / predicates ─────────────────────────────────────────────────
 
 fn simple(s: &str) -> TypeAnnotation {
-    TypeAnnotation::Simple(s.into())
+    TypeAnnotation::Simple(s.into(), tishlang_ast::Span::default())
 }
 fn is_any(ann: &TypeAnnotation) -> bool {
-    matches!(ann, TypeAnnotation::Simple(s) if s.as_ref() == "any")
+    matches!(ann, TypeAnnotation::Simple(s, _) if s.as_ref() == "any")
 }
 fn is_named(ann: &TypeAnnotation, n: &str) -> bool {
-    matches!(ann, TypeAnnotation::Simple(s) if s.as_ref() == n)
+    matches!(ann, TypeAnnotation::Simple(s, _) if s.as_ref() == n)
 }
 
 /// Display a type for diagnostics (close to the source syntax).
 fn show(ann: &TypeAnnotation) -> String {
     match ann {
-        TypeAnnotation::Simple(s) => s.to_string(),
+        TypeAnnotation::Simple(s, _) => s.to_string(),
         TypeAnnotation::Array(t) => format!("{}[]", show(t)),
         TypeAnnotation::Object(fs) => {
             let inner: Vec<String> = fs.iter().map(|(k, t)| format!("{}: {}", k, show(t))).collect();
@@ -116,7 +117,7 @@ fn resolve<'a>(
     if depth > 8 {
         return ann;
     }
-    if let TypeAnnotation::Simple(s) = ann {
+    if let TypeAnnotation::Simple(s, _) = ann {
         if let Some(t) = aliases.get(s.as_ref()) {
             return resolve(t, aliases, depth + 1);
         }
@@ -138,12 +139,12 @@ fn assignable(
     }
     // `null`/`void`/`undefined` are leniently compatible (tish uses `null` for optionals; checking
     // it strictly would false-positive without real union/optional support).
-    if matches!(a, TypeAnnotation::Simple(s) if matches!(s.as_ref(), "null" | "void" | "undefined")) {
+    if matches!(a, TypeAnnotation::Simple(s, _) if matches!(s.as_ref(), "null" | "void" | "undefined")) {
         return true;
     }
     use TypeAnnotation::*;
     match (a, e) {
-        (Simple(x), Simple(y)) => {
+        (Simple(x, _), Simple(y, _)) => {
             // Strict only among the three scalar primitives; any user-defined / unresolved name is
             // treated as compatible.
             let strict = |s: &str| matches!(s, "number" | "string" | "boolean");
@@ -155,7 +156,7 @@ fn assignable(
         }
         (Array(ax), Array(ey)) => assignable(ax, ey, aliases),
         // array vs non-array (after alias/any resolution) is a clear mismatch
-        (Array(_), Simple(_)) | (Simple(_), Array(_)) => false,
+        (Array(_), Simple(_, _)) | (Simple(_, _), Array(_)) => false,
         (Object(af), Object(ef)) => ef.iter().all(|(k, et)| {
             af.iter()
                 .find(|(ak, _)| ak.as_ref() == k.as_ref())
@@ -510,7 +511,7 @@ impl CheckCtx {
                         TypeAnnotation::Array(_) if name.as_ref() == "length" => {
                             return Some(simple("number"));
                         }
-                        TypeAnnotation::Simple(s)
+                        TypeAnnotation::Simple(s, _)
                             if s.as_ref() == "string" && name.as_ref() == "length" =>
                         {
                             return Some(simple("number"));
@@ -589,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));
                         }