@tishlang/tish 2.2.7 → 2.8.0

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));
                         }