@tishlang/tish 1.0.7 → 1.0.10

package/crates/tish_bytecode/src/encoding.rs

@@ -0,0 +1,100 @@
+//! Canonical u8 encoding for AST operators in bytecode.
+//! Single source of truth: compiler encodes with *\_to_u8, VM decodes with u8_to\_*.
+
+use tish_ast::{BinOp, CompoundOp, UnaryOp};
+
+/// Encode BinOp for bytecode operand. Used by compiler.
+pub fn binop_to_u8(op: BinOp) -> u8 {
+    use tish_ast::BinOp::*;
+    match op {
+        Add => 0,
+        Sub => 1,
+        Mul => 2,
+        Div => 3,
+        Mod => 4,
+        Pow => 5,
+        Eq => 6,
+        Ne => 7,
+        StrictEq => 8,
+        StrictNe => 9,
+        Lt => 10,
+        Le => 11,
+        Gt => 12,
+        Ge => 13,
+        And => 14,
+        Or => 15,
+        BitAnd => 16,
+        BitOr => 17,
+        BitXor => 18,
+        Shl => 19,
+        Shr => 20,
+        In => 21,
+    }
+}
+
+/// Decode bytecode operand to BinOp. Used by VM.
+pub fn u8_to_binop(b: u8) -> Option<BinOp> {
+    use tish_ast::BinOp::*;
+    Some(match b {
+        0 => Add,
+        1 => Sub,
+        2 => Mul,
+        3 => Div,
+        4 => Mod,
+        5 => Pow,
+        6 => Eq,
+        7 => Ne,
+        8 => StrictEq,
+        9 => StrictNe,
+        10 => Lt,
+        11 => Le,
+        12 => Gt,
+        13 => Ge,
+        14 => And,
+        15 => Or,
+        16 => BitAnd,
+        17 => BitOr,
+        18 => BitXor,
+        19 => Shl,
+        20 => Shr,
+        21 => In,
+        _ => return None,
+    })
+}
+
+/// Encode CompoundOp for bytecode (same numeric subset as BinOp: Add,Sub,Mul,Div,Mod).
+pub fn compound_op_to_u8(op: CompoundOp) -> u8 {
+    use tish_ast::CompoundOp::*;
+    match op {
+        Add => 0,
+        Sub => 1,
+        Mul => 2,
+        Div => 3,
+        Mod => 4,
+    }
+}
+
+/// Encode UnaryOp for bytecode operand. Used by compiler.
+pub fn unaryop_to_u8(op: UnaryOp) -> u8 {
+    use tish_ast::UnaryOp::*;
+    match op {
+        Not => 0,
+        Neg => 1,
+        Pos => 2,
+        BitNot => 3,
+        Void => 4,
+    }
+}
+
+/// Decode bytecode operand to UnaryOp. Used by VM.
+pub fn u8_to_unaryop(b: u8) -> Option<UnaryOp> {
+    use tish_ast::UnaryOp::*;
+    Some(match b {
+        0 => Not,
+        1 => Neg,
+        2 => Pos,
+        3 => BitNot,
+        4 => Void,
+        _ => return None,
+    })
+}

package/crates/tish_bytecode/src/lib.rs

@@ -0,0 +1,19 @@
+//! Bytecode compiler for Tish.
+//! Compiles AST to stack-based bytecode for VM execution.
+
+mod chunk;
+mod compiler;
+mod encoding;
+mod opcode;
+mod peephole;
+mod serialize;
+
+pub const NO_REST_PARAM: u16 = 0xFFFF;
+
+pub use chunk::{Chunk, Constant};
+pub use compiler::{
+    compile, compile_for_repl, compile_for_repl_unoptimized, compile_unoptimized, 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 serialize::{deserialize, serialize};

package/crates/tish_bytecode/src/opcode.rs

@@ -0,0 +1,110 @@
+//! Bytecode opcodes for the Tish VM.
+
+/// Stack-based bytecode opcodes.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum Opcode {
+    /// No operation
+    Nop = 0,
+    /// Push constant from constants table (operand: u16 index)
+    LoadConst = 1,
+    /// Load variable from scope (operand: u16 name index)
+    LoadVar = 2,
+    /// Store top of stack to variable (operand: u16 name index)
+    StoreVar = 3,
+    /// Discard top of stack
+    Pop = 4,
+    /// Duplicate top of stack
+    Dup = 5,
+    /// Call function with n args (operand: u16 arg count). Callee and args on stack.
+    Call = 6,
+    /// Return from function. Top of stack is return value.
+    Return = 7,
+    /// Unconditional jump forward (operand: u16 byte offset)
+    Jump = 8,
+    /// Pop top; if falsy, jump forward (operand: u16 byte offset)
+    JumpIfFalse = 9,
+    /// Unconditional jump backward (operand: u16 byte offset)
+    JumpBack = 10,
+    /// Binary operation (operand: u8 BinOp variant). Pops left, right; pushes result.
+    BinOp = 11,
+    /// Unary operation (operand: u8 UnaryOp variant). Pops operand; pushes result.
+    UnaryOp = 12,
+    /// Get property: obj.prop (operand: u16 prop name index). Pops obj; pushes value.
+    GetMember = 13,
+    /// Set property: obj.prop = val (operand: u16 prop name index). Pops obj, val.
+    SetMember = 14,
+    /// Get index: obj[idx]. Pops obj, idx; pushes value.
+    GetIndex = 15,
+    /// Set index: obj[idx] = val. Pops obj, idx, val.
+    SetIndex = 16,
+    /// Create array with n elements (operand: u16 count). Elements on stack.
+    NewArray = 17,
+    /// Create object with n key-value pairs (operand: u16 count). Keys and vals interleaved.
+    NewObject = 18,
+    /// Load from global scope (operand: u16 name index)
+    LoadGlobal = 19,
+    /// Store to global scope (operand: u16 name index)
+    StoreGlobal = 20,
+    /// Create closure: push function (operand: u16 chunk index for nested function)
+    Closure = 21,
+    /// Pop and discard n values (operand: u16 count)
+    PopN = 22,
+    /// Load `this` or receiver (for method calls)
+    LoadThis = 23,
+    /// Throw: pop value, unwind to catch handler, push value, jump
+    Throw = 24,
+    /// EnterTry: push handler (catch offset u16). Catch offset = bytes from end of this insn.
+    EnterTry = 25,
+    /// ExitTry: pop try handler
+    ExitTry = 26,
+    /// Concat arrays: pop right, pop left, push left.concat(right). For spread.
+    ConcatArray = 27,
+    /// Merge objects: pop right, pop left, push Object.assign({}, left, right). For object spread.
+    MergeObject = 28,
+    /// Call with spread: pop args array, pop callee, call callee(...args).
+    CallSpread = 29,
+    /// Get property optional: like GetMember but returns Null if obj is null or prop missing.
+    GetMemberOptional = 30,
+    /// Pop array, sort numerically in place (operand: u8 0=asc, 1=desc), push array.
+    /// Fast path for arr.sort((a,b)=>a-b) / arr.sort((a,b)=>b-a).
+    ArraySortNumeric = 31,
+    /// Pop array, sort by numeric property (operands: u16 prop_name_const_idx, u16 0=asc/1=desc).
+    /// Fast path for arr.sort((a,b)=>a.prop-b.prop).
+    ArraySortByProperty = 32,
+    /// arr.map(x => x) - identity, returns array clone.
+    ArrayMapIdentity = 33,
+    /// arr.map(x => x op const) or arr.map(x => const op x). Operands: u8 binop, u16 const_idx, u8 param_left (0=param on left e.g. x*2, 1=param on right e.g. 2*x).
+    ArrayMapBinOp = 34,
+    /// arr.filter(x => x op const) or arr.filter(x => const op x). Operands: u8 binop, u16 const_idx, u8 param_left. Keeps elements where result is truthy.
+    ArrayFilterBinOp = 35,
+    /// Load built-in module export. Operands: u16 spec_const_idx, u16 export_name_const_idx. Pushes Value.
+    LoadNativeExport = 36,
+}
+
+impl Opcode {
+    /// Decode byte to opcode. Safe for b in 0..=36 (matches #[repr(u8)] discriminants).
+    #[inline]
+    pub fn from_u8(b: u8) -> Option<Opcode> {
+        if b <= 36 {
+            Some(unsafe { std::mem::transmute(b) })
+        } else {
+            None
+        }
+    }
+
+    /// Size in bytes of this instruction at `ip` (including operands). Returns None if truncated.
+    pub fn instruction_size(self, code: &[u8], ip: usize) -> Option<usize> {
+        let size = match self {
+            Opcode::Nop | Opcode::Pop | Opcode::Dup | Opcode::Return | Opcode::ExitTry
+            | Opcode::ArrayMapIdentity => 1,
+            Opcode::ArraySortByProperty | Opcode::ArrayMapBinOp | Opcode::ArrayFilterBinOp
+            | Opcode::LoadNativeExport => 5,
+            _ => 3,
+        };
+        if ip + size > code.len() {
+            return None;
+        }
+        Some(size)
+    }
+}

package/crates/tish_bytecode/src/peephole.rs

@@ -0,0 +1,159 @@
+//! Peephole optimizations on bytecode (post-emission).
+//! B2 from optimization plan: jump chaining, etc.
+
+use crate::opcode::Opcode;
+use crate::Chunk;
+
+fn read_u16(code: &[u8], pos: usize) -> u16 {
+    if pos + 1 >= code.len() {
+        return 0;
+    }
+    let a = code[pos] as u16;
+    let b = code[pos + 1] as u16;
+    (a << 8) | b
+}
+
+fn read_i16(code: &[u8], pos: usize) -> i16 {
+    read_u16(code, pos) as i16
+}
+
+fn write_u16(code: &mut [u8], pos: usize, v: u16) {
+    if pos + 1 < code.len() {
+        let bytes = v.to_be_bytes();
+        code[pos] = bytes[0];
+        code[pos + 1] = bytes[1];
+    }
+}
+
+/// Size of instruction at `ip` in bytes. Returns None if invalid/truncated.
+fn instruction_size(code: &[u8], ip: usize) -> Option<usize> {
+    if ip >= code.len() {
+        return None;
+    }
+    let opcode = Opcode::from_u8(code[ip])?;
+    opcode.instruction_size(code, ip)
+}
+
+/// For a Jump or JumpIfFalse at `ip`, return the final target IP after following
+/// a chain of jumps (Jump -> Jump -> ... -> non-jump).
+fn final_jump_target(code: &[u8], jump_ip: usize) -> Option<usize> {
+    let mut ip = jump_ip;
+    let mut visited = 0u32;
+    const MAX_CHAIN: u32 = 1000;
+    loop {
+        if visited > MAX_CHAIN {
+            return None;
+        }
+        visited += 1;
+        let _ = instruction_size(code, ip)?;
+        let op = Opcode::from_u8(code[ip])?;
+        match op {
+            Opcode::Jump => {
+                let offset = read_i16(code, ip + 1) as isize;
+                ip = (ip as isize + 3 + offset).max(0) as usize;
+            }
+            Opcode::JumpIfFalse => {
+                let offset = read_i16(code, ip + 1) as isize;
+                ip = (ip as isize + 3 + offset).max(0) as usize;
+            }
+            _ => return Some(ip),
+        }
+    }
+}
+
+/// Replace instruction at [ip..ip+len) with Nops (preserves length, no offset updates).
+fn nop_out(code: &mut [u8], ip: usize, len: usize) {
+    for i in 0..len {
+        if ip + i < code.len() {
+            code[ip + i] = Opcode::Nop as u8;
+        }
+    }
+}
+
+/// Remove redundant Dup + Pop (dup top then discard = no-op).
+fn remove_dup_pop(code: &mut [u8]) {
+    let mut ip = 0;
+    while ip + 2 <= code.len() {
+        if Opcode::from_u8(code[ip]) == Some(Opcode::Dup)
+            && Opcode::from_u8(code[ip + 1]) == Some(Opcode::Pop)
+        {
+            nop_out(code, ip, 2);
+        }
+        ip += instruction_size(code, ip).unwrap_or(1);
+    }
+}
+
+/// Remove redundant LoadConst + Pop (load constant then discard = no-op).
+fn remove_loadconst_pop(code: &mut [u8]) {
+    let mut ip = 0;
+    while ip + 4 <= code.len() {
+        if Opcode::from_u8(code[ip]) == Some(Opcode::LoadConst)
+            && Opcode::from_u8(code[ip + 3]) == Some(Opcode::Pop)
+        {
+            nop_out(code, ip, 4);
+        }
+        ip += instruction_size(code, ip).unwrap_or(1);
+    }
+}
+
+/// Replace no-op jumps (Jump with offset 0) with Nops.
+fn remove_noop_jumps(code: &mut [u8]) {
+    let mut ip = 0;
+    while ip < code.len() {
+        if Opcode::from_u8(code[ip]) == Some(Opcode::Jump) {
+            let offset = read_u16(code, ip + 1);
+            if offset == 0 {
+                nop_out(code, ip, 3);
+            }
+        }
+        ip += instruction_size(code, ip).unwrap_or(1);
+    }
+}
+
+/// Apply jump chaining: if Jump/JumpIfFalse targets another jump, update to
+/// jump directly to the final target.
+fn chain_jumps(code: &mut [u8]) {
+    let mut ip = 0;
+    while ip < code.len() {
+        let op = match Opcode::from_u8(code[ip]) {
+            Some(o) => o,
+            None => {
+                ip += 1;
+                continue;
+            }
+        };
+        let size = match instruction_size(code, ip) {
+            Some(s) => s,
+            None => break,
+        };
+        match op {
+            Opcode::Jump | Opcode::JumpIfFalse => {
+                let current_offset = read_i16(code, ip + 1) as isize;
+                let current_target = (ip as isize + 3 + current_offset).max(0) as usize;
+                if let Some(final_target) = final_jump_target(code, ip) {
+                    if final_target != current_target {
+                        let new_offset = final_target as i32 - (ip + 3) as i32;
+                        let bytes = (new_offset as i16).to_be_bytes();
+                        if ip + 2 < code.len() {
+                            code[ip + 1] = bytes[0];
+                            code[ip + 2] = bytes[1];
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+        ip += size;
+    }
+}
+
+/// Run peephole optimizations on a chunk (and nested chunks).
+pub fn optimize(chunk: &mut Chunk) {
+    remove_loadconst_pop(&mut chunk.code);
+    remove_dup_pop(&mut chunk.code);
+    remove_noop_jumps(&mut chunk.code);
+    chain_jumps(&mut chunk.code);
+    for nested in &mut chunk.nested {
+        optimize(nested);
+    }
+}

package/crates/tish_bytecode/src/serialize.rs

@@ -0,0 +1,163 @@
+//! Chunk serialization for embedding in native/WASM outputs.
+//! Format: code, constants, names, nested (recursive).
+
+use std::sync::Arc;
+
+use super::{Chunk, Constant};
+
+/// Serialize a chunk to bytes (includes nested chunks for functions).
+pub fn serialize(chunk: &Chunk) -> Vec<u8> {
+    let mut out = Vec::new();
+    out.extend_from_slice(&(chunk.code.len() as u64).to_le_bytes());
+    out.extend_from_slice(&chunk.code);
+    out.extend_from_slice(&(chunk.constants.len() as u64).to_le_bytes());
+    for c in &chunk.constants {
+        match c {
+            Constant::Number(n) => {
+                out.push(0);
+                out.extend_from_slice(&n.to_le_bytes());
+            }
+            Constant::String(s) => {
+                out.push(1);
+                let b = s.as_bytes();
+                out.extend_from_slice(&(b.len() as u64).to_le_bytes());
+                out.extend_from_slice(b);
+            }
+            Constant::Bool(b) => {
+                out.push(2);
+                out.push(if *b { 1 } else { 0 });
+            }
+            Constant::Null => out.push(3),
+            Constant::Closure(idx) => {
+                out.push(4);
+                out.extend_from_slice(&(*idx as u64).to_le_bytes());
+            }
+        }
+    }
+    out.extend_from_slice(&(chunk.names.len() as u64).to_le_bytes());
+    for n in &chunk.names {
+        let b = n.as_bytes();
+        out.extend_from_slice(&(b.len() as u64).to_le_bytes());
+        out.extend_from_slice(b);
+    }
+    out.extend_from_slice(&(chunk.nested.len() as u64).to_le_bytes());
+    for nested in &chunk.nested {
+        let nested_bytes = serialize(nested);
+        out.extend_from_slice(&(nested_bytes.len() as u64).to_le_bytes());
+        out.extend_from_slice(&nested_bytes);
+    }
+    out.extend_from_slice(&chunk.rest_param_index.to_le_bytes());
+    out.extend_from_slice(&chunk.param_count.to_le_bytes());
+    out
+}
+
+/// Deserialize a chunk from bytes.
+pub fn deserialize(mut data: &[u8]) -> Result<Chunk, String> {
+    let read_u64 = |d: &mut &[u8]| {
+        if d.len() < 8 {
+            return Err("Unexpected EOF".to_string());
+        }
+        let (head, tail) = d.split_at(8);
+        *d = tail;
+        Ok(u64::from_le_bytes(head.try_into().unwrap()))
+    };
+
+    let code_len = read_u64(&mut data)? as usize;
+    if data.len() < code_len {
+        return Err("Truncated code".to_string());
+    }
+    let (code_bytes, rest) = data.split_at(code_len);
+    data = rest;
+    let code = code_bytes.to_vec();
+
+    let const_count = read_u64(&mut data)? as usize;
+    let mut constants = Vec::with_capacity(const_count);
+    for _ in 0..const_count {
+        if data.is_empty() {
+            return Err("Truncated constant".to_string());
+        }
+        let tag = data[0];
+        data = &data[1..];
+        let c = match tag {
+            0 => {
+                if data.len() < 8 {
+                    return Err("Truncated number".to_string());
+                }
+                let (n_bytes, rest) = data.split_at(8);
+                data = rest;
+                Constant::Number(f64::from_le_bytes(n_bytes.try_into().unwrap()))
+            }
+            1 => {
+                let str_len = read_u64(&mut data)? as usize;
+                if data.len() < str_len {
+                    return Err("Truncated string".to_string());
+                }
+                let (s_bytes, rest) = data.split_at(str_len);
+                data = rest;
+                Constant::String(Arc::from(String::from_utf8_lossy(s_bytes).into_owned()))
+            }
+            2 => {
+                if data.is_empty() {
+                    return Err("Truncated bool".to_string());
+                }
+                let b = data[0] != 0;
+                data = &data[1..];
+                Constant::Bool(b)
+            }
+            3 => Constant::Null,
+            4 => {
+                let idx = read_u64(&mut data)? as usize;
+                Constant::Closure(idx)
+            }
+            _ => return Err(format!("Unknown constant tag: {}", tag)),
+        };
+        constants.push(c);
+    }
+
+    let names_count = read_u64(&mut data)? as usize;
+    let mut names = Vec::with_capacity(names_count);
+    for _ in 0..names_count {
+        let n_len = read_u64(&mut data)? as usize;
+        if data.len() < n_len {
+            return Err("Truncated name".to_string());
+        }
+        let (n_bytes, rest) = data.split_at(n_len);
+        data = rest;
+        names.push(Arc::from(String::from_utf8_lossy(n_bytes).into_owned()));
+    }
+
+    let nested_count = read_u64(&mut data)? as usize;
+    let mut nested = Vec::with_capacity(nested_count);
+    for _ in 0..nested_count {
+        let nested_len = read_u64(&mut data)? as usize;
+        if data.len() < nested_len {
+            return Err("Truncated nested chunk".to_string());
+        }
+        let (nested_data, rest) = data.split_at(nested_len);
+        data = rest;
+        nested.push(deserialize(nested_data)?);
+    }
+
+    let rest_param_index = if data.len() >= 2 {
+        let (r_bytes, rest) = data.split_at(2);
+        data = rest;
+        u16::from_le_bytes(r_bytes.try_into().unwrap())
+    } else {
+        super::NO_REST_PARAM
+    };
+    let param_count = if data.len() >= 2 {
+        let (p_bytes, _) = data.split_at(2);
+        u16::from_le_bytes(p_bytes.try_into().unwrap())
+    } else {
+        0
+    };
+
+    Ok(Chunk {
+        code,
+        constants,
+        names,
+        nested,
+        rest_param_index,
+        param_count,
+    })
+}

package/crates/tish_bytecode/tests/constant_folding.rs

@@ -0,0 +1,84 @@
+//! Verify AST optimization (constant folding) yields expected bytecode.
+//! Uses tish_opt::optimize before compile to match the pipeline used by run/compile.
+
+use tish_bytecode::{compile, Chunk, Opcode};
+use tish_parser::parse;
+
+fn chunk_contains_opcode(chunk: &Chunk, op: u8) -> bool {
+    if chunk.code.contains(&op) {
+        return true;
+    }
+    for nested in &chunk.nested {
+        if chunk_contains_opcode(nested, op) {
+            return true;
+        }
+    }
+    false
+}
+
+/// 1 + 2 should fold to constant 3; no BinOp in bytecode.
+#[test]
+fn constant_fold_binary_no_binop() {
+    let source = "1 + 2";
+    let program = parse(source).expect("parse");
+    let optimized = tish_opt::optimize(&program);
+    let chunk = compile(&optimized).expect("compile");
+    assert!(
+        !chunk_contains_opcode(&chunk, Opcode::BinOp as u8),
+        "Expected no BinOp for 1+2 after constant folding"
+    );
+    assert!(
+        chunk.constants.iter().any(|c| matches!(c, tish_bytecode::Constant::Number(n) if (*n - 3.0).abs() < f64::EPSILON)),
+        "Expected constant 3 in chunk"
+    );
+}
+
+/// Peephole: Dup+Pop should be removed (replaced with Nop Nop).
+/// Compile a program that may emit Dup+Pop; verify it runs and chunk has no consecutive Dup,Pop.
+fn chunk_has_dup_pop_sequence(code: &[u8]) -> bool {
+    let dup = Opcode::Dup as u8;
+    let pop = Opcode::Pop as u8;
+    for i in 0..code.len().saturating_sub(1) {
+        if code[i] == dup && code[i + 1] == pop {
+            return true;
+        }
+    }
+    false
+}
+
+fn chunk_contains_dup_pop(chunk: &Chunk) -> bool {
+    if chunk_has_dup_pop_sequence(&chunk.code) {
+        return true;
+    }
+    for nested in &chunk.nested {
+        if chunk_contains_dup_pop(nested) {
+            return true;
+        }
+    }
+    false
+}
+
+#[test]
+fn peephole_remove_dup_pop() {
+    let source = "let o = {a:1}; o?.a";
+    let program = parse(source).expect("parse");
+    let optimized = tish_opt::optimize(&program);
+    let chunk = compile(&optimized).expect("compile");
+    assert!(
+        !chunk_contains_dup_pop(&chunk),
+        "Peephole should remove Dup+Pop sequences"
+    );
+}
+
+/// -42 should fold to constant -42; no UnaryOp in bytecode.
+#[test]
+fn constant_fold_unary_no_unaryop() {
+    let source = "-42";
+    let program = parse(source).expect("parse");
+    let optimized = tish_opt::optimize(&program);
+    let chunk = compile(&optimized).expect("compile");
+    assert!(
+        !chunk_contains_opcode(&chunk, Opcode::UnaryOp as u8),
+        "Expected no UnaryOp for -42 after constant folding"
+    );
+}

package/crates/tish_bytecode/tests/shortcircuit.rs

@@ -0,0 +1,49 @@
+//! Verify && and || short-circuit (JumpIfFalse before evaluating right side).
+use std::path::Path;
+use tish_bytecode::{compile, compile_unoptimized, Opcode};
+use tish_compile::{merge_modules, resolve_project};
+use tish_parser::parse;
+use tish_opt;
+use tish_vm;
+
+#[test]
+fn test_and_shortcircuit_emits_jump() {
+    let source = "let x = null; let y = x != null && x.foo;";
+    let program = parse(source).expect("parse");
+    let chunk = compile_unoptimized(&program).expect("compile");
+    let code = &chunk.code;
+    let has_jump_if_false = code.windows(1).any(|w| w[0] == Opcode::JumpIfFalse as u8);
+    assert!(has_jump_if_false, "And should emit JumpIfFalse for short-circuit");
+}
+
+#[test]
+fn test_and_shortcircuit_runs_unoptimized() {
+    let source = "let x = null; let y = x != null && x.foo;";
+    let program = parse(source).expect("parse");
+    let chunk = compile_unoptimized(&program).expect("compile");
+    let result = tish_vm::run(&chunk);
+    assert!(result.is_ok(), "Should not throw (short-circuit avoids x.foo): {:?}", result.err());
+}
+
+#[test]
+fn test_and_shortcircuit_runs_optimized() {
+    let source = "let x = null; let y = x != null && x.foo;";
+    let program = parse(source).expect("parse");
+    let program = tish_opt::optimize(&program);
+    let chunk = tish_bytecode::compile(&program).expect("compile");
+    let result = tish_vm::run(&chunk);
+    assert!(result.is_ok(), "Should not throw with peephole (short-circuit): {:?}", result.err());
+}
+
+#[test]
+fn test_and_shortcircuit_via_resolve_project() {
+    let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/shortcircuit.tish");
+    let path = path.canonicalize().expect("path");
+    let project_root = path.parent().unwrap();
+    let modules = resolve_project(&path, Some(project_root)).expect("resolve");
+    let program = merge_modules(modules).expect("merge");
+    let program = tish_opt::optimize(&program); // Mirror CLI
+    let chunk = compile(&program).expect("compile");
+    let result = tish_vm::run(&chunk);
+    assert!(result.is_ok(), "Should not throw via resolve+merge+opt (CLI path): {:?}", result.err());
+}