@tishlang/tish 1.3.4 → 1.3.8

package/LICENSE

@@ -1,6 +1,6 @@
 Pay It Forward License (PIF)
 
-Copyright (c) 2025 The Tish Project Authors
+Copyright (c) 2025-present The Tish Project Authors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.3.4"
+version = "1.3.8"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/tests/run_optimize_stdout_parity.rs

@@ -0,0 +1,54 @@
+//! Ensure `tish run` and `tish run --no-optimize` agree on stdout for the same program.
+
+use std::path::PathBuf;
+use std::process::Command;
+
+#[test]
+fn string_or_fixture_stdout_matches_with_and_without_optimize() {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("..")
+        .join("tish_vm")
+        .join("tests")
+        .join("fixtures")
+        .join("or_string_cmd.tish");
+    assert!(fixture.is_file(), "missing fixture {}", fixture.display());
+
+    let out_default = Command::new(&tish)
+        .args([
+            "run",
+            "--feature",
+            "process",
+            fixture.to_str().unwrap(),
+        ])
+        .output()
+        .expect("spawn tish run");
+    assert!(
+        out_default.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&out_default.stderr)
+    );
+
+    let out_noopt = Command::new(&tish)
+        .args([
+            "run",
+            "--no-optimize",
+            "--feature",
+            "process",
+            fixture.to_str().unwrap(),
+        ])
+        .output()
+        .expect("spawn tish run --no-optimize");
+    assert!(
+        out_noopt.status.success(),
+        "stderr: {}",
+        String::from_utf8_lossy(&out_noopt.stderr)
+    );
+
+    assert_eq!(
+        out_default.stdout, out_noopt.stdout,
+        "stdout differs:\n default: {:?}\n noopt: {:?}",
+        String::from_utf8_lossy(&out_default.stdout),
+        String::from_utf8_lossy(&out_noopt.stdout)
+    );
+}

package/crates/tish_bytecode/src/peephole.rs

@@ -34,10 +34,22 @@ fn instruction_size(code: &[u8], ip: usize) -> Option<usize> {
     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;
+/// Advance past `Nop` bytes left by other peepholes (`Dup`+`Pop` → `Nop`+`Nop`, etc.).
+/// Jump resolution must not treat a `Nop` run as the end of a chain, or we leave a jump
+/// targeting the middle of padding while `chain_jumps` redirects another jump past it —
+/// that misaligns `||` short-circuit when nested in an outer `if`.
+fn skip_leading_nops(code: &[u8], mut ip: usize) -> usize {
+    while ip < code.len() && Opcode::from_u8(code[ip]) == Some(Opcode::Nop) {
+        ip += 1;
+    }
+    ip
+}
+
+/// After a branch lands at `ip`, follow only **unconditional** `Jump` instructions.
+/// Must not follow `JumpIfFalse`: that opcode is conditional; treating it like `Jump`
+/// breaks short-circuit codegen (e.g. `a === 1 || b === 2` inside `if (...)`).
+fn skip_unconditional_jump_chain(code: &[u8], mut ip: usize) -> Option<usize> {
+    ip = skip_leading_nops(code, ip);
     let mut visited = 0u32;
     const MAX_CHAIN: u32 = 1000;
     loop {
@@ -45,22 +57,39 @@ fn final_jump_target(code: &[u8], jump_ip: usize) -> Option<usize> {
             return None;
         }
         visited += 1;
+        if ip > code.len() {
+            return None;
+        }
+        if ip == code.len() {
+            return Some(ip);
+        }
         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),
+        if op != Opcode::Jump {
+            return Some(ip);
         }
+        let offset = read_i16(code, ip + 1) as isize;
+        ip = (ip as isize + 3 + offset).max(0) as usize;
+        ip = skip_leading_nops(code, ip);
     }
 }
 
+/// For a `Jump` or `JumpIfFalse` at `jump_ip`, return the final IP after resolving the
+/// taken branch and then skipping through any **unconditional** `Jump` chain only.
+fn final_jump_target(code: &[u8], jump_ip: usize) -> Option<usize> {
+    let _ = instruction_size(code, jump_ip)?;
+    let op = Opcode::from_u8(code[jump_ip])?;
+    let first_target = match op {
+        Opcode::Jump | Opcode::JumpIfFalse => {
+            let offset = read_i16(code, jump_ip + 1) as isize;
+            (jump_ip as isize + 3 + offset).max(0) as usize
+        }
+        _ => return Some(jump_ip),
+    };
+    let first_target = skip_leading_nops(code, first_target);
+    skip_unconditional_jump_chain(code, first_target)
+}
+
 /// 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 {

package/crates/tish_core/src/console_style.rs

@@ -2,6 +2,9 @@
 //!
 //! Use for REPL, console.log, and any terminal output so numbers, strings,
 //! booleans, null, and object structure are easier to scan.
+//!
+//! `console.log` prints string arguments without surrounding quotes (like Node); nested
+//! strings inside arrays/objects stay quoted. The REPL still quotes string results for clarity.
 
 use std::io::IsTerminal;
 use std::sync::OnceLock;
@@ -40,10 +43,12 @@ pub fn format_value_styled(value: &Value, colors: bool) -> String {
     if !colors {
         return value.to_display_string();
     }
-    format_value_styled_inner(value, colors)
+    format_value_styled_inner(value, colors, true)
 }
 
-fn format_value_styled_inner(value: &Value, colors: bool) -> String {
+/// `quote_strings`: when true (REPL / inspect), strings render as quoted literals. When false
+/// (top-level `console.log` arguments), strings render raw like Node.
+fn format_value_styled_inner(value: &Value, colors: bool, quote_strings: bool) -> String {
     match value {
         Value::Number(n) => {
             let s = if n.is_nan() {
@@ -58,8 +63,12 @@ fn format_value_styled_inner(value: &Value, colors: bool) -> String {
             format!("{NUMBER}{s}{RESET}")
         }
         Value::String(s) => {
-            let escaped = escape_string_for_display(s);
-            format!("{STRING}\"{escaped}\"{RESET}")
+            if quote_strings {
+                let escaped = escape_string_for_display(s);
+                format!("{STRING}\"{escaped}\"{RESET}")
+            } else {
+                format!("{STRING}{}{RESET}", s.as_ref())
+            }
         }
         Value::Bool(b) => format!("{BOOLEAN}{b}{RESET}"),
         Value::Null => format!("{NULL}null{RESET}"),
@@ -67,7 +76,7 @@ fn format_value_styled_inner(value: &Value, colors: bool) -> String {
             let inner: Vec<String> = arr
                 .borrow()
                 .iter()
-                .map(|v| format_value_styled_inner(v, colors))
+                .map(|v| format_value_styled_inner(v, colors, true))
                 .collect();
             let sep = format!("{PUNCT}, {RESET}");
             format!("{PUNCT}[{RESET}{}{PUNCT}]{RESET}", inner.join(&sep))
@@ -80,7 +89,7 @@ fn format_value_styled_inner(value: &Value, colors: bool) -> String {
                     format!(
                         "{KEY}{}{RESET}{PUNCT}: {RESET}{}",
                         k.as_ref(),
-                        format_value_styled_inner(v, colors)
+                        format_value_styled_inner(v, colors, true)
                     )
                 })
                 .collect();
@@ -123,10 +132,18 @@ pub fn format_values_for_console(values: &[Value], colors: bool) -> String {
     match iter.next() {
         None => String::new(),
         Some(first) => {
-            let mut result = format_value_styled(first, colors);
+            let mut result = if colors {
+                format_value_styled_inner(first, colors, false)
+            } else {
+                first.to_display_string()
+            };
             for v in iter {
                 result.push(' ');
-                result.push_str(&format_value_styled(v, colors));
+                if colors {
+                    result.push_str(&format_value_styled_inner(v, colors, false));
+                } else {
+                    result.push_str(&v.to_display_string());
+                }
             }
             result
         }

package/crates/tish_vm/Cargo.toml

@@ -27,7 +27,9 @@ rand = "0.10"
 wasm-bindgen = { version = "0.2", optional = true }
 
 [dev-dependencies]
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
+tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.4", features = ["wasm_js"] }

package/crates/tish_vm/src/vm.rs

@@ -37,6 +37,10 @@ fn get_builtin_export(spec: &str, export_name: &str) -> Option<Value> {
     #[cfg(feature = "http")]
     if spec == "tish:http" {
         return match export_name {
+            // Bytecode compiler lowers `await expr` to `tish:http.await(promise)` (see tish_bytecode compiler).
+            "await" => Some(Value::Function(Rc::new(|args: &[Value]| {
+                tishlang_runtime::await_promise(args.first().cloned().unwrap_or(Value::Null))
+            }))),
             "fetch" => Some(Value::Function(Rc::new(|args: &[Value]| {
                 tishlang_runtime::fetch_promise(args.to_vec())
             }))),

package/crates/tish_vm/tests/fixtures/or_string_cmd.tish

@@ -0,0 +1,2 @@
+let cmd = "a"
+if (cmd === "a" || cmd === "b") { console.log("hit") } else { console.log("miss") }

package/crates/tish_vm/tests/peephole_jump_chain_logical_or.rs

@@ -0,0 +1,143 @@
+//! Regression: bytecode peephole `chain_jumps` must not follow `JumpIfFalse` as if it were an
+//! unconditional `Jump`. Doing so broke `===` + `||` when nested as the condition of an outer `if`
+//! (default VM differed from `--backend interp` / `--no-optimize`).
+//!
+//! CLI parity for the same source is covered in `crates/tish/tests/run_optimize_stdout_parity.rs`.
+
+use std::path::PathBuf;
+
+use tishlang_bytecode::{
+    compile, compile_for_repl, compile_for_repl_unoptimized, compile_unoptimized,
+};
+use tishlang_core::Value;
+
+fn run_chunk(chunk: &tishlang_bytecode::Chunk) -> Value {
+    tishlang_vm::run(chunk).expect("vm run")
+}
+
+/// `tish run` ends with trailing `null` when the last statement is not a REPL-style expr; use
+/// `compile_for_repl` so the VM return value reflects the `||` result (catches peephole/AST bugs).
+#[test]
+fn string_strict_eq_logical_or_repl_last_expr_is_true() {
+    let src = "let cmd = \"a\"\ncmd === \"a\" || cmd === \"b\"";
+    let opt = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&opt).expect("compile repl"));
+    let v_unopt = run_chunk(&compile_for_repl_unoptimized(&opt).expect("compile repl unopt"));
+    assert!(
+        v_peep.strict_eq(&v_unopt),
+        "peephole vs unopt repl: peep={v_peep:?} unopt={v_unopt:?}"
+    );
+    assert!(
+        matches!(&v_peep, Value::Bool(true)),
+        "expected true for cmd===a||cmd===b with cmd=a, got {v_peep:?}"
+    );
+}
+
+/// `?:` uses different codegen than `if`; both must agree with unoptimized bytecode.
+#[test]
+fn string_strict_eq_logical_or_inside_ternary_repl_last_expr() {
+    // Statement boundary: without `;` or `;`-like ASI, the parser can tie the `(` line to `let`.
+    let src = "let cmd = \"a\"\n;(cmd === \"a\" || cmd === \"b\") ? 1 : 0";
+    let opt = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&opt).expect("compile repl"));
+    let v_unopt = run_chunk(&compile_for_repl_unoptimized(&opt).expect("compile repl unopt"));
+    assert!(v_peep.strict_eq(&v_unopt), "peep={v_peep:?} unopt={v_unopt:?}");
+    assert!(
+        matches!(&v_peep, Value::Number(n) if *n == 1.0),
+        "expected 1, got {v_peep:?}"
+    );
+}
+
+#[test]
+fn logical_or_strict_eq_peephole_matches_unoptimized() {
+    let src = "let a = 1\nlet b = 2\na === 1 || b === 2";
+    let program = tishlang_parser::parse(src).expect("parse");
+    let program = tishlang_opt::optimize(&program);
+
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("compile unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "peephole changed semantics: peep={v_peep:?} raw={v_raw:?}"
+    );
+
+    let v_peep_repl = run_chunk(&compile_for_repl(&program).expect("compile repl"));
+    let v_raw_repl = run_chunk(&compile_for_repl_unoptimized(&program).expect("compile repl unopt"));
+    assert!(
+        v_peep_repl.strict_eq(&v_raw_repl),
+        "repl: peep={v_peep_repl:?} raw={v_raw_repl:?}"
+    );
+}
+
+#[test]
+fn logical_or_inside_if_condition_peephole_matches_unoptimized() {
+    let src = "let a = 1\nlet b = 2\nif (a === 1 || b === 2) { 1 } else { 0 }";
+    let program = tishlang_parser::parse(src).expect("parse");
+    let program = tishlang_opt::optimize(&program);
+
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("compile unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "if + || : peep={v_peep:?} raw={v_raw:?}"
+    );
+}
+
+#[test]
+fn string_strict_eq_logical_or_ast_opt_matches_unoptimized_bytecode() {
+    let src = "let cmd = \"a\"\nif (cmd === \"a\" || cmd === \"b\") { 1 } else { 0 }";
+    let raw = tishlang_parser::parse(src).expect("parse");
+    let opt = tishlang_opt::optimize(&raw);
+    let v_raw = run_chunk(&compile_unoptimized(&raw).expect("raw"));
+    let v_opt = run_chunk(&compile_unoptimized(&opt).expect("opt"));
+    assert!(
+        v_raw.strict_eq(&v_opt),
+        "AST optimizer changed semantics: raw={v_raw:?} opt={v_opt:?}"
+    );
+}
+
+#[test]
+fn string_strict_eq_logical_or_peephole_matches_unoptimized() {
+    let src = "let cmd = \"a\"\nif (cmd === \"a\" || cmd === \"b\") { 1 } else { 0 }";
+    let program = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile(&program).expect("compile"));
+    let v_raw = run_chunk(&compile_unoptimized(&program).expect("unopt"));
+    assert!(
+        v_peep.strict_eq(&v_raw),
+        "peephole + strings: peep={v_peep:?} raw={v_raw:?}"
+    );
+}
+
+/// `tish run path/to/file.tish` uses merge_modules; ensure that matches plain parse for the fixture.
+#[test]
+fn merged_module_program_bytecode_matches_parse_for_string_or_fixture() {
+    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/or_string_cmd.tish");
+    let src = std::fs::read_to_string(&fixture).expect("read fixture");
+    let modules = tishlang_compile::resolve_project(&fixture, Some(fixture.parent().unwrap()))
+        .expect("resolve");
+    let merged = tishlang_compile::merge_modules(modules).expect("merge");
+    let flat = tishlang_parser::parse(&src).expect("parse");
+    let m_opt = tishlang_opt::optimize(&merged);
+    let f_opt = tishlang_opt::optimize(&flat);
+    let c_m = compile(&m_opt).expect("compile merged");
+    let c_f = compile(&f_opt).expect("compile flat");
+    assert_eq!(
+        c_m.code, c_f.code,
+        "merge_modules vs parse produced different bytecode"
+    );
+}
+
+/// `if (cmd === "a" || cmd === "b")` must match unoptimized VM semantics (Nop padding from other
+/// peepholes must not confuse `chain_jumps`).
+#[test]
+fn string_eq_or_in_if_stmt_matches_unoptimized_repl() {
+    let src = "let cmd = \"a\"\nlet ok = false\nif (cmd === \"a\" || cmd === \"b\") { ok = true } else { ok = false }\nok";
+    let program = tishlang_opt::optimize(&tishlang_parser::parse(src).expect("parse"));
+    let v_peep = run_chunk(&compile_for_repl(&program).expect("compile repl"));
+    let v_raw = run_chunk(&compile_for_repl_unoptimized(&program).expect("compile repl unopt"));
+    assert!(v_peep.strict_eq(&v_raw), "peep={v_peep:?} raw={v_raw:?}");
+    assert!(
+        matches!(&v_peep, Value::Bool(true)),
+        "expected ok=true, got {v_peep:?}"
+    );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.3.4",
+  "version": "1.3.8",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {