@tishlang/tish-format 3.3.3 → 3.7.0

package/crates/tish_test/src/instrument.rs

@@ -0,0 +1,457 @@
+//! AST instrumentation for line coverage — rewrite programs in `tish_test` only.
+
+use std::path::Path;
+use std::sync::Arc;
+
+use tishlang_ast::{
+    ArrowBody, CallArg, ExportDeclaration, Expr, Literal, Program, Span, Statement,
+};
+
+use crate::coverage::{self, hit_global_name};
+
+/// Instrument every resolved module's AST so execution of any backend records line hits.
+pub fn instrument_program(program: &mut Program, path: &Path) {
+    if !coverage::is_enabled() {
+        return;
+    }
+    let file_id = coverage::intern_file(path);
+    program.statements = instrument_stmts(std::mem::take(&mut program.statements), file_id);
+}
+
+fn instrument_stmts(stmts: Vec<Statement>, file_id: u32) -> Vec<Statement> {
+    let mut out = Vec::with_capacity(stmts.len() * 2);
+    for stmt in stmts {
+        match stmt {
+            Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. }
+            | Statement::Import { .. } => {
+                out.push(stmt);
+            }
+            Statement::Export { declaration, span } => {
+                let declaration = Box::new(match *declaration {
+                    ExportDeclaration::Named(inner) => {
+                        ExportDeclaration::Named(Box::new(instrument_stmt(*inner, file_id)))
+                    }
+                    ExportDeclaration::Default(expr) => {
+                        ExportDeclaration::Default(instrument_expr(expr, file_id))
+                    }
+                    other => other,
+                });
+                out.push(hit_stmt(file_id, span.start.0 as u32));
+                out.push(Statement::Export { declaration, span });
+            }
+            Statement::Multi { statements, span } => {
+                out.push(Statement::Multi {
+                    statements: instrument_stmts(statements, file_id),
+                    span,
+                });
+            }
+            Statement::Block { statements, span } => {
+                out.push(Statement::Block {
+                    statements: instrument_stmts(statements, file_id),
+                    span,
+                });
+            }
+            other => {
+                let line = other.span().start.0 as u32;
+                out.push(hit_stmt(file_id, line));
+                out.push(instrument_stmt(other, file_id));
+            }
+        }
+    }
+    out
+}
+
+fn instrument_stmt(stmt: Statement, file_id: u32) -> Statement {
+    match stmt {
+        Statement::Block { statements, span } => Statement::Block {
+            statements: instrument_stmts(statements, file_id),
+            span,
+        },
+        Statement::Multi { statements, span } => Statement::Multi {
+            statements: instrument_stmts(statements, file_id),
+            span,
+        },
+        Statement::If {
+            cond,
+            then_branch,
+            else_branch,
+            span,
+        } => Statement::If {
+            cond: instrument_expr(cond, file_id),
+            then_branch: Box::new(instrument_stmt(*then_branch, file_id)),
+            else_branch: else_branch.map(|b| Box::new(instrument_stmt(*b, file_id))),
+            span,
+        },
+        Statement::While { cond, body, span } => Statement::While {
+            cond: instrument_expr(cond, file_id),
+            body: Box::new(instrument_stmt(*body, file_id)),
+            span,
+        },
+        Statement::DoWhile { body, cond, span } => Statement::DoWhile {
+            body: Box::new(instrument_stmt(*body, file_id)),
+            cond: instrument_expr(cond, file_id),
+            span,
+        },
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
+            span,
+        } => Statement::For {
+            init: init.map(|i| Box::new(instrument_stmt(*i, file_id))),
+            cond: cond.map(|c| instrument_expr(c, file_id)),
+            update: update.map(|u| instrument_expr(u, file_id)),
+            body: Box::new(instrument_stmt(*body, file_id)),
+            span,
+        },
+        Statement::ForOf {
+            name,
+            name_span,
+            iterable,
+            body,
+            span,
+        } => Statement::ForOf {
+            name,
+            name_span,
+            iterable: instrument_expr(iterable, file_id),
+            body: Box::new(instrument_stmt(*body, file_id)),
+            span,
+        },
+        Statement::ForIn {
+            name,
+            name_span,
+            object,
+            body,
+            span,
+        } => Statement::ForIn {
+            name,
+            name_span,
+            object: instrument_expr(object, file_id),
+            body: Box::new(instrument_stmt(*body, file_id)),
+            span,
+        },
+        Statement::FunDecl {
+            async_,
+            name,
+            name_span,
+            params,
+            rest_param,
+            return_type,
+            body,
+            span,
+        } => Statement::FunDecl {
+            async_,
+            name,
+            name_span,
+            params,
+            rest_param,
+            return_type,
+            body: Box::new(instrument_stmt(*body, file_id)),
+            span,
+        },
+        Statement::Try {
+            body,
+            catch_param,
+            catch_param_span,
+            catch_body,
+            finally_body,
+            span,
+        } => Statement::Try {
+            body: Box::new(instrument_stmt(*body, file_id)),
+            catch_param,
+            catch_param_span,
+            catch_body: catch_body.map(|b| Box::new(instrument_stmt(*b, file_id))),
+            finally_body: finally_body.map(|b| Box::new(instrument_stmt(*b, file_id))),
+            span,
+        },
+        Statement::Switch {
+            expr,
+            cases,
+            default_body,
+            span,
+        } => Statement::Switch {
+            expr: instrument_expr(expr, file_id),
+            cases: cases
+                .into_iter()
+                .map(|(c, body)| {
+                    (
+                        c.map(|e| instrument_expr(e, file_id)),
+                        instrument_stmts(body, file_id),
+                    )
+                })
+                .collect(),
+            default_body: default_body.map(|b| instrument_stmts(b, file_id)),
+            span,
+        },
+        Statement::ExprStmt { expr, span } => Statement::ExprStmt {
+            expr: instrument_expr(expr, file_id),
+            span,
+        },
+        Statement::VarDecl {
+            name,
+            name_span,
+            mutable,
+            type_ann,
+            init,
+            span,
+        } => Statement::VarDecl {
+            name,
+            name_span,
+            mutable,
+            type_ann,
+            init: init.map(|e| instrument_expr(e, file_id)),
+            span,
+        },
+        Statement::VarDeclDestructure {
+            pattern,
+            mutable,
+            init,
+            span,
+        } => Statement::VarDeclDestructure {
+            pattern,
+            mutable,
+            init: instrument_expr(init, file_id),
+            span,
+        },
+        Statement::Return { value, span } => Statement::Return {
+            value: value.map(|e| instrument_expr(e, file_id)),
+            span,
+        },
+        Statement::Throw { value, span } => Statement::Throw {
+            value: instrument_expr(value, file_id),
+            span,
+        },
+        other => other,
+    }
+}
+
+fn instrument_expr(expr: Expr, file_id: u32) -> Expr {
+    match expr {
+        Expr::ArrowFunction {
+            async_,
+            params,
+            body,
+            span,
+        } => Expr::ArrowFunction {
+            async_,
+            params,
+            body: match body {
+                ArrowBody::Expr(e) => ArrowBody::Expr(Box::new(instrument_expr(*e, file_id))),
+                ArrowBody::Block(b) => ArrowBody::Block(Box::new(instrument_stmt(*b, file_id))),
+            },
+            span,
+        },
+        Expr::Call { callee, args, span } => Expr::Call {
+            callee: Box::new(instrument_expr(*callee, file_id)),
+            args: args
+                .into_iter()
+                .map(|a| match a {
+                    CallArg::Expr(e) => CallArg::Expr(instrument_expr(e, file_id)),
+                    CallArg::Spread(e) => CallArg::Spread(instrument_expr(e, file_id)),
+                })
+                .collect(),
+            span,
+        },
+        Expr::Binary {
+            left,
+            op,
+            right,
+            span,
+        } => Expr::Binary {
+            left: Box::new(instrument_expr(*left, file_id)),
+            op,
+            right: Box::new(instrument_expr(*right, file_id)),
+            span,
+        },
+        Expr::Unary { op, operand, span } => Expr::Unary {
+            op,
+            operand: Box::new(instrument_expr(*operand, file_id)),
+            span,
+        },
+        Expr::Member {
+            object,
+            prop,
+            optional,
+            span,
+        } => Expr::Member {
+            object: Box::new(instrument_expr(*object, file_id)),
+            prop,
+            optional,
+            span,
+        },
+        Expr::Assign { name, value, span } => Expr::Assign {
+            name,
+            value: Box::new(instrument_expr(*value, file_id)),
+            span,
+        },
+        Expr::Array { elements, span } => Expr::Array {
+            elements: elements
+                .into_iter()
+                .map(|el| match el {
+                    tishlang_ast::ArrayElement::Expr(e) => {
+                        tishlang_ast::ArrayElement::Expr(instrument_expr(e, file_id))
+                    }
+                    tishlang_ast::ArrayElement::Spread(e) => {
+                        tishlang_ast::ArrayElement::Spread(instrument_expr(e, file_id))
+                    }
+                })
+                .collect(),
+            span,
+        },
+        Expr::Object { props, span } => Expr::Object {
+            props: props
+                .into_iter()
+                .map(|p| match p {
+                    tishlang_ast::ObjectProp::KeyValue(k, v, s) => {
+                        tishlang_ast::ObjectProp::KeyValue(k, instrument_expr(v, file_id), s)
+                    }
+                    tishlang_ast::ObjectProp::Spread(e) => {
+                        tishlang_ast::ObjectProp::Spread(instrument_expr(e, file_id))
+                    }
+                })
+                .collect(),
+            span,
+        },
+        // Every remaining expression form that can nest an arrow function. Missing one does not
+        // fail loudly: the arrow's body is simply never marked executable, so it drops out of
+        // the denominator and inflates the reported percentage.
+        Expr::New { callee, args, span } => Expr::New {
+            callee: Box::new(instrument_expr(*callee, file_id)),
+            args: args
+                .into_iter()
+                .map(|a| match a {
+                    CallArg::Expr(e) => CallArg::Expr(instrument_expr(e, file_id)),
+                    CallArg::Spread(e) => CallArg::Spread(instrument_expr(e, file_id)),
+                })
+                .collect(),
+            span,
+        },
+        Expr::Index {
+            object,
+            index,
+            optional,
+            span,
+        } => Expr::Index {
+            object: Box::new(instrument_expr(*object, file_id)),
+            index: Box::new(instrument_expr(*index, file_id)),
+            optional,
+            span,
+        },
+        Expr::Conditional {
+            cond,
+            then_branch,
+            else_branch,
+            span,
+        } => Expr::Conditional {
+            cond: Box::new(instrument_expr(*cond, file_id)),
+            then_branch: Box::new(instrument_expr(*then_branch, file_id)),
+            else_branch: Box::new(instrument_expr(*else_branch, file_id)),
+            span,
+        },
+        Expr::NullishCoalesce { left, right, span } => Expr::NullishCoalesce {
+            left: Box::new(instrument_expr(*left, file_id)),
+            right: Box::new(instrument_expr(*right, file_id)),
+            span,
+        },
+        Expr::Await { operand, span } => Expr::Await {
+            operand: Box::new(instrument_expr(*operand, file_id)),
+            span,
+        },
+        Expr::TypeOf { operand, span } => Expr::TypeOf {
+            operand: Box::new(instrument_expr(*operand, file_id)),
+            span,
+        },
+        Expr::Delete { target, span } => Expr::Delete {
+            target: Box::new(instrument_expr(*target, file_id)),
+            span,
+        },
+        Expr::CompoundAssign {
+            name,
+            op,
+            value,
+            span,
+        } => Expr::CompoundAssign {
+            name,
+            op,
+            value: Box::new(instrument_expr(*value, file_id)),
+            span,
+        },
+        Expr::LogicalAssign {
+            name,
+            op,
+            value,
+            span,
+        } => Expr::LogicalAssign {
+            name,
+            op,
+            value: Box::new(instrument_expr(*value, file_id)),
+            span,
+        },
+        Expr::MemberAssign {
+            object,
+            prop,
+            value,
+            span,
+        } => Expr::MemberAssign {
+            object: Box::new(instrument_expr(*object, file_id)),
+            prop,
+            value: Box::new(instrument_expr(*value, file_id)),
+            span,
+        },
+        Expr::IndexAssign {
+            object,
+            index,
+            value,
+            span,
+        } => Expr::IndexAssign {
+            object: Box::new(instrument_expr(*object, file_id)),
+            index: Box::new(instrument_expr(*index, file_id)),
+            value: Box::new(instrument_expr(*value, file_id)),
+            span,
+        },
+        Expr::TemplateLiteral {
+            quasis,
+            exprs,
+            span,
+        } => Expr::TemplateLiteral {
+            quasis,
+            exprs: exprs
+                .into_iter()
+                .map(|e| instrument_expr(e, file_id))
+                .collect(),
+            span,
+        },
+        // Literals, identifiers, increments/decrements and JSX carry no nested arrow bodies
+        // that statement-level instrumentation would otherwise miss.
+        other => other,
+    }
+}
+
+fn hit_stmt(file_id: u32, line: u32) -> Statement {
+    coverage::mark_executable(file_id, line);
+    let span = Span {
+        start: (line as usize, 1),
+        end: (line as usize, 1),
+    };
+    let name: Arc<str> = Arc::from(hit_global_name());
+    Statement::ExprStmt {
+        expr: Expr::Call {
+            callee: Box::new(Expr::Ident { name, span }),
+            args: vec![
+                CallArg::Expr(Expr::Literal {
+                    value: Literal::Number(file_id as f64),
+                    span,
+                }),
+                CallArg::Expr(Expr::Literal {
+                    value: Literal::Number(line as f64),
+                    span,
+                }),
+            ],
+            span,
+        },
+        span,
+    }
+}

package/crates/tish_test/src/isolation.rs

@@ -0,0 +1,14 @@
+//! Per-file isolation hooks for multi-file `tish test` runs.
+//!
+//! Clears pending throws and the mock registry between files. Timers / HTTP static routes /
+//! sockets are **not** reset in-process — suites that leak host state should use separate
+//! processes.
+
+use tishlang_core::take_pending_throw;
+
+/// Reset host state between test files in the same process.
+pub fn reset_between_files() {
+    let _ = take_pending_throw();
+    // Otherwise `restoreAllMocks()` in one file drains handles registered by another.
+    crate::mocks::reset_mock_registry();
+}

package/crates/tish_test/src/lib.rs

@@ -0,0 +1,22 @@
+//! Native `tish test` runner, Bun/Jest-shaped `tish:test`, and Node-mirrored `tish:assert`.
+
+pub mod assert;
+pub mod config;
+pub mod coverage;
+pub mod deep_equal;
+pub mod discovery;
+pub mod expect;
+pub mod instrument;
+pub mod isolation;
+pub mod mocks;
+pub mod module;
+pub mod registry;
+pub mod report;
+pub mod runner;
+pub mod snapshots;
+
+#[cfg(feature = "runner")]
+pub mod load;
+
+pub use module::{assert_module, test_module};
+pub use runner::{run_tests, run_tests_watch, TestOptions, TestRunResult};

package/crates/tish_test/src/load.rs

@@ -0,0 +1,152 @@
+//! Load a test file into the suite registry (requires `runner` feature).
+
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use crate::coverage::{self, hit_global_name, hit_value};
+use crate::instrument::instrument_program;
+use crate::module::{assert_module, test_module};
+use crate::registry::{begin_collect, end_collect, take_collect_errors, SuiteNode};
+
+/// A loaded file plus any errors thrown while collecting its suites.
+pub struct LoadedSuite {
+    pub suite: SuiteNode,
+    /// Throws that escaped a `describe` body. These silently truncate registration, so the
+    /// runner reports them as failures instead of letting the file look green.
+    pub collect_errors: Vec<String>,
+}
+
+/// Resolve, merge, optimize, and execute `path` so `describe`/`test` callbacks register
+/// into the collect-then-run suite tree. Suppresses printing the program's last value.
+///
+/// `preload` modules run first **on the same VM instance**, so anything they define or
+/// register (globals, `beforeEach` hooks) is visible to the test file. `features` restricts VM
+/// capabilities exactly as `tish run --feature` does; an empty list means "everything linked
+/// into this binary".
+pub fn load_and_collect_tests(
+    path: &Path,
+    preload: &[PathBuf],
+    backend: &str,
+    no_optimize: bool,
+    features: &[String],
+) -> Result<LoadedSuite, String> {
+    let path = path
+        .canonicalize()
+        .map_err(|e| format!("Cannot resolve {}: {}", path.display(), e))?;
+
+    begin_collect(&path.to_string_lossy());
+
+    let mut programs = Vec::with_capacity(preload.len() + 1);
+    for pre in preload {
+        let pre = pre
+            .canonicalize()
+            .map_err(|e| format!("Cannot resolve preload {}: {}", pre.display(), e))?;
+        let program = compile_program(&pre, no_optimize)
+            .map_err(|e| format!("Error loading preload {}: {}", pre.display(), e))?;
+        programs.push((pre, program));
+    }
+    programs.push((path.clone(), compile_program(&path, no_optimize)?));
+
+    let result = match backend {
+        "vm" => run_vm(&programs, features),
+        other => {
+            return Err(format!(
+                "unsupported --backend `{other}` for tish test (use `vm`)"
+            ));
+        }
+    };
+
+    let suite = end_collect();
+    let collect_errors = take_collect_errors();
+    result?;
+    Ok(LoadedSuite {
+        suite,
+        collect_errors,
+    })
+}
+
+fn compile_program(path: &Path, no_optimize: bool) -> Result<tishlang_ast::Program, String> {
+    let project_root = path.parent().and_then(|p| {
+        if p.file_name().and_then(|n| n.to_str()) == Some("src") {
+            p.parent()
+        } else {
+            Some(p)
+        }
+    });
+
+    let mut modules = tishlang_compile::resolve_project(path, project_root)?;
+    tishlang_compile::detect_cycles(&modules)?;
+
+    // Instrument each module's AST in this crate so vm / interp / future backends share hits.
+    // A module reached from more than one test file must only be instrumented once, or its
+    // statements would be double-counted (and re-wrapped) on the second load.
+    if coverage::is_enabled() {
+        for m in &mut modules {
+            if coverage::mark_instrumented(&m.path) {
+                instrument_program(&mut m.program, &m.path);
+            }
+        }
+    }
+
+    let prog = tishlang_compile::merge_modules(modules)?.program;
+    Ok(if no_optimize {
+        prog
+    } else {
+        tishlang_opt::optimize(&prog)
+    })
+}
+
+/// VM capability set, matching `tish run`: empty `--feature` means every capability linked
+/// into this binary; otherwise exactly the requested set (`full` expands).
+fn vm_capabilities(features: &[String]) -> HashSet<String> {
+    if features.is_empty() {
+        return tishlang_vm::all_compiled_capabilities();
+    }
+    let mut out = HashSet::new();
+    for s in features {
+        for part in s.split(',').map(str::trim).filter(|p| !p.is_empty()) {
+            if part == "full" {
+                for name in ["http", "timers", "fs", "process", "regex", "ws", "tty"] {
+                    out.insert(name.to_string());
+                }
+            } else {
+                out.insert(part.to_string());
+            }
+        }
+    }
+    out
+}
+
+fn run_vm(
+    programs: &[(PathBuf, tishlang_ast::Program)],
+    features: &[String],
+) -> Result<(), String> {
+    let mut vm = tishlang_vm::Vm::with_capabilities(vm_capabilities(features));
+    // `node:assert` / `assert/strict` are normalized to `tish:assert` during resolution, so
+    // only the canonical specs need registering.
+    vm.register_native_module("tish:test", test_module());
+    vm.register_native_module("tish:assert", assert_module());
+    if coverage::is_enabled() {
+        vm.set_global(Arc::from(hit_global_name()), hit_value());
+    }
+
+    for (path, program) in programs {
+        let source_arc: Arc<str> = Arc::from(path.to_string_lossy().as_ref());
+        let mut chunk = tishlang_bytecode::compile_with_source(program, Some(source_arc.clone()))
+            .map_err(|e| e.to_string())?;
+        chunk.source = Some(source_arc);
+
+        vm.run_with_options(&chunk, false)
+            .map_err(|e| format!("Error loading {}: {}", path.display(), e))?;
+        if tishlang_core::has_pending_throw() {
+            let err = tishlang_core::take_pending_throw().unwrap_or(tishlang_core::Value::Null);
+            return Err(format!(
+                "Error loading {}: {}",
+                path.display(),
+                err.to_display_string()
+            ));
+        }
+    }
+    Ok(())
+}