@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish_bytecode/tests/break_continue_bytecode.rs

@@ -0,0 +1,44 @@
+//! Regression: C-style `for` `continue` must jump forward to the update clause (not JumpBack).
+
+use std::fs;
+
+use tishlang_bytecode::{compile, compile_unoptimized};
+use tishlang_vm::run;
+
+#[test]
+fn break_continue_fixture_runs_on_vm() {
+    let path = format!(
+        "{}/../../tests/core/break_continue.tish",
+        env!("CARGO_MANIFEST_DIR")
+    );
+    let src = fs::read_to_string(&path).unwrap();
+    let prog = tishlang_parser::parse(&src).expect("parse");
+    let chunk = compile_unoptimized(&prog).expect("compile");
+    run(&chunk).expect("VM run");
+}
+
+#[test]
+fn mutation_vm_ast_opt_without_peephole() {
+    let path = format!(
+        "{}/../../tests/core/mutation.tish",
+        env!("CARGO_MANIFEST_DIR")
+    );
+    let src = fs::read_to_string(&path).unwrap();
+    let mut prog = tishlang_parser::parse(&src).expect("parse");
+    tishlang_opt::optimize(&mut prog);
+    let chunk = compile_unoptimized(&prog).expect("compile");
+    run(&chunk).expect("VM");
+}
+
+#[test]
+fn mutation_vm_ast_opt_with_peephole() {
+    let path = format!(
+        "{}/../../tests/core/mutation.tish",
+        env!("CARGO_MANIFEST_DIR")
+    );
+    let src = fs::read_to_string(&path).unwrap();
+    let mut prog = tishlang_parser::parse(&src).expect("parse");
+    tishlang_opt::optimize(&mut prog);
+    let chunk = compile(&prog).expect("compile");
+    run(&chunk).expect("VM");
+}

package/crates/tish_bytecode/tests/constant_folding.rs

@@ -0,0 +1,84 @@
+//! Verify AST optimization (constant folding) yields expected bytecode.
+//! Uses tishlang_opt::optimize before compile to match the pipeline used by run/compile.
+
+use tishlang_bytecode::{compile, Chunk, Opcode};
+use tishlang_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 = tishlang_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, tishlang_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 = tishlang_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 = tishlang_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/sort_optimization.rs

@@ -0,0 +1,31 @@
+//! Verify arr.sort((a,b)=>a-b) compiles to ArraySortNumeric (opcode 31).
+
+use tishlang_bytecode::{compile, Opcode};
+use tishlang_parser::parse;
+
+fn chunk_contains_opcode(chunk: &tishlang_bytecode::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
+}
+
+#[test]
+fn test_numeric_sort_uses_array_sort_numeric() {
+    let source = r#"
+        let x = [3, 1, 2];
+        x.sort((a, b) => a - b);
+        console.log(x);
+    "#;
+    let program = parse(source).expect("parse");
+    let chunk = compile(&program).expect("compile");
+    assert!(
+        chunk_contains_opcode(&chunk, Opcode::ArraySortNumeric as u8),
+        "Expected ArraySortNumeric (31) in bytecode for x.sort((a,b)=>a-b)"
+    );
+}

package/crates/tish_compile/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "tishlang_compile"
+version = "0.1.0"
+edition = "2021"
+description = "Tish native compiler backend"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+[features]
+default = []
+http = []
+timers = []
+fs = []
+process = []
+regex = []
+ws = []
+tty = []
+
+[dependencies]
+tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
+tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
+tishlang_ui = { path = "../tish_ui", version = ">=0.1", default-features = false, features = ["compiler"] }
+serde_json = "1.0"
+
+[dev-dependencies]
+tempfile = "3"