@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish/tests/run_optimize_stdout_parity.rs

@@ -0,0 +1,50 @@
+//! 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/tests/shortcircuit.rs

@@ -0,0 +1,65 @@
+//! Verify && and || short-circuit (JumpIfFalse before evaluating right side).
+//! Moved from tish_bytecode to break publish cycle (bytecode dev-depends on vm, vm depends on bytecode).
+use std::path::Path;
+use tishlang_bytecode::{compile, compile_unoptimized, Opcode};
+use tishlang_compile::{merge_modules, resolve_project};
+use tishlang_opt;
+use tishlang_parser::parse;
+use tishlang_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 = tishlang_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 = tishlang_opt::optimize(&program);
+    let chunk = tishlang_bytecode::compile(&program).expect("compile");
+    let result = tishlang_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").program;
+    let program = tishlang_opt::optimize(&program); // Mirror CLI
+    let chunk = compile(&program).expect("compile");
+    let result = tishlang_vm::run(&chunk);
+    assert!(
+        result.is_ok(),
+        "Should not throw via resolve+merge+opt (CLI path): {:?}",
+        result.err()
+    );
+}

package/crates/tish/tests/trycatch_runtime_errors.rs

@@ -0,0 +1,45 @@
+//! Issue #60: `try/catch` must catch VM-internal runtime errors (property/method access on
+//! null, calling a non-function) AND `throw`s that propagate across function-call frames,
+//! preserving the thrown value. Verified on the bytecode VM and the tree-walk interpreter
+//! (the two backends #60 targets — the embedded/browser target is the VM, the interpreter is
+//! its oracle). The native backend surfaces these as Rust panics and is tracked separately.
+
+use std::path::PathBuf;
+use std::process::Command;
+
+const EXPECTED: &str = "\
+A caught
+B caught: boom
+C caught
+D done
+E caught: rethrown
+F ok
+G total: 206
+";
+
+fn run(backend: &str, fixture: &str) -> String {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let out = Command::new(&tish)
+        .args(["run", "--backend", backend, fixture])
+        .output()
+        .expect("spawn tish run");
+    assert!(
+        out.status.success(),
+        "tish run --backend {backend} failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    String::from_utf8_lossy(&out.stdout).into_owned()
+}
+
+#[test]
+fn trycatch_catches_runtime_and_cross_frame_errors() {
+    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join("trycatch_runtime_errors.tish");
+    assert!(fixture.is_file(), "missing fixture {}", fixture.display());
+    let fixture = fixture.to_str().unwrap();
+
+    assert_eq!(run("vm", fixture), EXPECTED, "vm output mismatch");
+    assert_eq!(run("interp", fixture), EXPECTED, "interp output mismatch");
+}

package/crates/tish/tests/tty_capability.rs

@@ -0,0 +1,43 @@
+//! Issue #101: the `tish:tty` capability (raw mode, terminal size, key/resize events) is
+//! available on every backend behind the `tty` feature. CI has no real terminal, so this
+//! asserts the module loads and degrades gracefully (size → null, isTTY → a boolean, the
+//! event/raw-mode primitives are functions). Interactive behavior is covered manually.
+
+use std::path::PathBuf;
+use std::process::Command;
+
+const EXPECTED: &str = "\
+isTTY: boolean
+size: null
+setRawMode: function
+read: function
+readLine: function
+alt: function function
+";
+
+fn run(backend: &str, fixture: &str) -> String {
+    let tish = PathBuf::from(env!("CARGO_BIN_EXE_tish"));
+    let out = Command::new(&tish)
+        .args(["run", "--backend", backend, "--feature", "tty", fixture])
+        .output()
+        .expect("spawn tish run");
+    assert!(
+        out.status.success(),
+        "tish run --backend {backend} failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    String::from_utf8_lossy(&out.stdout).into_owned()
+}
+
+#[test]
+fn tty_module_loads_and_degrades_without_a_terminal() {
+    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join("tty_capability.tish");
+    assert!(fixture.is_file(), "missing fixture {}", fixture.display());
+    let fixture = fixture.to_str().unwrap();
+
+    assert_eq!(run("vm", fixture), EXPECTED, "vm output mismatch");
+    assert_eq!(run("interp", fixture), EXPECTED, "interp output mismatch");
+}

package/crates/tish_ast/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "tishlang_ast"
+version = "0.1.0"
+edition = "2021"
+description = "Tish AST types and span info"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+[dependencies]