@tishlang/tish 1.13.2 → 2.0.1

package/crates/tish_bytecode/src/encoding.rs

@@ -29,6 +29,7 @@ pub fn binop_to_u8(op: BinOp) -> u8 {
         Shl => 19,
         Shr => 20,
         In => 21,
+        UShr => 22,
     }
 }
 
@@ -58,6 +59,7 @@ pub fn u8_to_binop(b: u8) -> Option<BinOp> {
         19 => Shl,
         20 => Shr,
         21 => In,
+        22 => UShr,
         _ => return None,
     })
 }

package/crates/tish_bytecode/src/lib.rs

@@ -12,7 +12,8 @@ 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,
+    compile, compile_for_repl, compile_for_repl_unoptimized, compile_unoptimized,
+    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;

package/crates/tish_bytecode/src/opcode.rs

@@ -96,14 +96,51 @@ pub enum Opcode {
     /// Pop the `await` operand value; if it is a `Promise`, block until settled, push the result,
     /// or unwind to `catch` like `Throw` on rejection.
     AwaitPromise = 43,
+    /// Load a local variable by frame slot (operand: u16 slot). Fast path: direct
+    /// index into the current call frame's locals, no name lookup.
+    LoadLocal = 44,
+    /// Store top of stack into a local frame slot (operand: u16 slot). Leaves nothing.
+    StoreLocal = 45,
+    /// Load a captured variable from an enclosing frame (operands: u16 hops, u16 slot).
+    /// Walks `hops` parent frames, then indexes `slot`.
+    LoadUpvalue = 46,
+    /// Store top of stack into an enclosing frame slot (operands: u16 hops, u16 slot).
+    StoreUpvalue = 47,
+    /// Begin a per-iteration binding region for a loop variable (operand: u16 name index).
+    /// Registers the name so closures created in the loop body snapshot it into a fresh overlay
+    /// (ES `let` per-iteration semantics); the rest of the frame stays shared. Emitted only when
+    /// the loop body creates a closure, so closure-free (hot) loops are untouched.
+    LoopVarsBegin = 48,
+    /// End the innermost per-iteration binding region (no operand).
+    LoopVarsEnd = 49,
+    /// Push `Bool(param_index >= argc)` — true when the positional argument at `param_index`
+    /// was not supplied by the caller (operand: u16 param index). Emitted by the function
+    /// prologue so default parameter values apply only for *missing* args, matching the
+    /// interpreter: an explicit `null` argument does NOT trigger the default.
+    ArgMissing = 50,
+    /// Direct self-recursive call (operand: u16 arg count). Emitted by the compiler ONLY when a
+    /// `fn NAME` body calls `NAME(args)` and `NAME` is provably the function itself (not shadowed
+    /// by a param/local, not reassigned anywhere in the body). Args are on the stack as for `Call`,
+    /// but the callee is implicitly the currently-executing chunk — no name lookup, no closure
+    /// dispatch. The numeric JIT lowers this to a native recursive call (the big recursion win);
+    /// the VM runs the current chunk directly. Behaviour is identical to `LoadVar NAME; Call argc`.
+    SelfCall = 51,
+    /// Normalize the top-of-stack iterable for `for…of`: a JS iterator object (one with a
+    /// callable `next()` returning `{ value, done }`, e.g. a `Map`/`Set` `.values()` result)
+    /// is drained into an array; arrays/strings/anything else pass through unchanged. Emitted
+    /// right after the iterable expression so the existing index-based loop can iterate it.
+    IterNormalize = 52,
+    /// `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,
 }
 
 impl Opcode {
-    /// Decode byte to opcode. Safe for b in 0..=43 (matches #[repr(u8)] discriminants).
+    /// Decode byte to opcode. Safe for b in 0..=53 (matches #[repr(u8)] discriminants).
     #[inline]
     pub fn from_u8(b: u8) -> Option<Opcode> {
-        if b <= 43 {
-            Some(unsafe { std::mem::transmute(b) })
+        if b <= 53 {
+            Some(unsafe { std::mem::transmute::<u8, Opcode>(b) })
         } else {
             None
         }
@@ -127,11 +164,17 @@ impl Opcode {
             | Opcode::ConstructSpread
             | Opcode::EnterBlock
             | Opcode::ExitBlock
+            | Opcode::LoopVarsEnd
+            | Opcode::IterNormalize
+            | Opcode::DeleteIndex
             | Opcode::AwaitPromise => 1,
             Opcode::ArraySortByProperty
             | Opcode::ArrayMapBinOp
             | Opcode::ArrayFilterBinOp
-            | Opcode::LoadNativeExport => 5,
+            | Opcode::LoadNativeExport
+            | Opcode::LoadUpvalue
+            | Opcode::StoreUpvalue => 5,
+            // LoadLocal / StoreLocal take a single u16 operand → 3 bytes (default).
             _ => 3,
         };
         if ip + size > code.len() {

package/crates/tish_bytecode/src/serialize.rs

@@ -48,6 +48,8 @@ pub fn serialize(chunk: &Chunk) -> Vec<u8> {
     }
     out.extend_from_slice(&chunk.rest_param_index.to_le_bytes());
     out.extend_from_slice(&chunk.param_count.to_le_bytes());
+    out.extend_from_slice(&chunk.num_slots.to_le_bytes());
+    out.push(if chunk.slot_based { 1 } else { 0 });
     out
 }
 
@@ -146,12 +148,34 @@ pub fn deserialize(mut data: &[u8]) -> Result<Chunk, String> {
         super::NO_REST_PARAM
     };
     let param_count = if data.len() >= 2 {
-        let (p_bytes, _) = data.split_at(2);
+        let (p_bytes, rest) = data.split_at(2);
+        data = rest;
         u16::from_le_bytes(p_bytes.try_into().unwrap())
     } else {
         0
     };
+    let num_slots = if data.len() >= 2 {
+        let (s_bytes, rest) = data.split_at(2);
+        data = rest;
+        u16::from_le_bytes(s_bytes.try_into().unwrap())
+    } else {
+        0
+    };
+    let slot_based = if !data.is_empty() {
+        let b = data[0] != 0;
+        data = &data[1..];
+        b
+    } else {
+        false
+    };
+    let _ = data;
 
+    // Inline caches are a runtime-only cache, not serialized — start empty, sized to `names`.
+    let inline_caches = crate::chunk::InlineCaches(
+        (0..names.len())
+            .map(|_| std::sync::atomic::AtomicU64::new(0))
+            .collect(),
+    );
     Ok(Chunk {
         code,
         constants,
@@ -159,5 +183,11 @@ pub fn deserialize(mut data: &[u8]) -> Result<Chunk, String> {
         nested,
         rest_param_index,
         param_count,
+        num_slots,
+        slot_based,
+        inline_caches,
+        // Debug-only; not part of the serialized format (issue #74).
+        lines: Vec::new(),
+        source: None,
     })
 }

package/crates/tish_compile/Cargo.toml

@@ -14,6 +14,7 @@ fs = []
 process = []
 regex = []
 ws = []
+tty = []
 
 [dependencies]
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }