@tishlang/tish-lsp 3.3.3 → 3.7.0

package/Cargo.toml

@@ -33,6 +33,7 @@ members = [
     "crates/tish_lsp",
     "crates/tish_resolve",
     "crates/tishlang_cargo_bindgen",
+    "crates/tish_test",
 ]
 # Generated native-build projects (`tish build`) land under `target/` when TMPDIR points there;
 # never enroll anything beneath `target/` as a workspace member.

package/crates/tish/Cargo.toml

@@ -25,7 +25,7 @@ path = "src/main.rs"
 default = ["full", "fast-alloc"]
 # Alias: same dependency edges as `default` (kept for `--features full` in CI and docs).
 # Includes `pg` so `tish run` can resolve `import … from '@tishlang/pg'` (`cargo:tish_pg`) on the bytecode VM.
-full = ["http", "fs", "process", "regex", "ws", "timers", "tty", "pg"]
+full = ["http", "fs", "process", "regex", "ws", "timers", "tty", "pg", "test-runner"]
 # Fast allocator (mimalloc) as the process `#[global_allocator]`. tish's object/array/string workloads
 # are allocation-bound (a sampling profile of object-heavy code spends ~14%+ in system malloc/free);
 # mimalloc is markedly faster for the many-small-allocations pattern — the same reason JSC ships bmalloc.
@@ -33,6 +33,8 @@ full = ["http", "fs", "process", "regex", "ws", "timers", "tty", "pg"]
 fast-alloc = ["dep:mimalloc"]
 # Opt-out: build without Postgres (`cargo build -p tishlang --no-default-features --features http,...`).
 pg = ["dep:tishlang_pg"]
+# Native `tish test` runner (`tish:test` / `tish:assert`).
+test-runner = ["dep:tishlang_test"]
 # Individual capability flags
 http    = ["tishlang_eval/http",    "tishlang_runtime/http",    "tishlang_compile/http",    "tishlang_vm/http"]
 timers  = ["tishlang_eval/timers",  "tishlang_compile/timers",  "tishlang_vm/timers"]
@@ -58,6 +60,7 @@ tishlang_wasm = { path = "../tish_wasm", version = ">=0.1" }
 tishlang_runtime = { path = "../tish_runtime", version = ">=0.1" }
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 tishlang_js_to_tish = { path = "../js_to_tish", version = ">=0.1" }
+tishlang_test = { path = "../tish_test", optional = true, features = ["runner", "fs", "regex", "promise", "watch"] }
 clap = { version = "4.6.0", features = ["derive", "color"] }
 serde_json = "1"
 tishlang_pg = { path = "../tish_pg", version = ">=0.1", optional = true }

package/crates/tish/src/cli_help.rs

@@ -631,12 +631,96 @@ pub(crate) struct CompileModuleArgs {
     pub file: String,
 }
 
+#[derive(Parser)]
+pub(crate) struct TestArgs {
+    /// File or directory filters (paths / substrings). Omit to discover under the current directory.
+    #[arg(num_args = 0.., value_name = "FILTER", help_heading = "Arguments")]
+    pub filters: Vec<String>,
+    /// Execution backend. Only `vm` runs tests today.
+    #[arg(
+        long,
+        default_value = "vm",
+        value_name = "NAME",
+        help_heading = "Options"
+    )]
+    pub backend: String,
+    /// Restrict which platform APIs tests may use, as `tish run --feature` does
+    /// (omit = all capabilities compiled into this `tish`). Enforced on `--backend vm`.
+    #[arg(
+        long = "feature",
+        value_name = "NAME",
+        action = clap::ArgAction::Append,
+        help_heading = "Options"
+    )]
+    pub features: Vec<String>,
+    /// Disable AST and bytecode optimizations.
+    #[arg(long, help_heading = "Options")]
+    pub no_optimize: bool,
+    /// Only run tests whose full name matches this regex.
+    #[arg(short = 't', long = "test-name-pattern", value_name = "REGEX", help_heading = "Options")]
+    pub test_name_pattern: Option<String>,
+    /// Per-test timeout in milliseconds (default 5000). Loops are interrupted at the deadline;
+    /// a body blocked inside one native call is only caught once it returns.
+    #[arg(long, default_value = "5000", value_name = "MS", help_heading = "Options")]
+    pub timeout: u64,
+    /// Update snapshot files on mismatch (`-u`).
+    #[arg(short = 'u', long = "update-snapshots", help_heading = "Options")]
+    pub update_snapshots: bool,
+    /// Fail on a missing snapshot instead of writing it (also on when `CI` is set).
+    #[arg(long, help_heading = "Options")]
+    pub ci: bool,
+    /// Stop after the first failing test file / suite.
+    #[arg(long, help_heading = "Options")]
+    pub bail: bool,
+    /// Retry failed tests this many times.
+    #[arg(long, default_value = "0", value_name = "N", help_heading = "Options")]
+    pub retry: u32,
+    /// Only run tests marked `.only`.
+    #[arg(long, help_heading = "Options")]
+    pub only: bool,
+    /// Reporter: `console` (default) or `dots`.
+    #[arg(long, default_value = "console", value_name = "NAME", help_heading = "Options")]
+    pub reporter: String,
+    /// Write a JUnit XML report to this path.
+    #[arg(long = "reporter-outfile", value_name = "PATH", help_heading = "Options")]
+    pub reporter_outfile: Option<String>,
+    /// Re-run tests when files under discovery roots change (requires notify).
+    #[arg(long, help_heading = "Options")]
+    pub watch: bool,
+    /// Shuffle test file order.
+    #[arg(long, help_heading = "Options")]
+    pub randomize: bool,
+    /// Seed for `--randomize` (implies randomize).
+    #[arg(long, value_name = "N", help_heading = "Options")]
+    pub seed: Option<u64>,
+    /// Run the suite this many times; any failing pass fails the command (`--rerun-each`).
+    #[arg(long = "rerun-each", default_value = "1", value_name = "N", help_heading = "Options")]
+    pub rerun_each: u32,
+    /// Shard files as `i/n` (1-based index).
+    #[arg(long, value_name = "I/N", help_heading = "Options")]
+    pub shard: Option<String>,
+    /// Only run tests that include this tag (repeatable).
+    #[arg(long = "tag", value_name = "TAG", action = clap::ArgAction::Append, help_heading = "Options")]
+    pub tags: Vec<String>,
+    /// Preload module paths (evaluated before each test file, on the same backend instance).
+    #[arg(long = "preload", value_name = "FILE", action = clap::ArgAction::Append, help_heading = "Options")]
+    pub preload: Vec<String>,
+    /// Collect line coverage via AST instrumentation.
+    #[arg(long, help_heading = "Options")]
+    pub coverage: bool,
+    /// Write `lcov.info` under this directory (implies `--coverage`). Default: `coverage/`.
+    #[arg(long = "coverage-dir", value_name = "DIR", help_heading = "Options")]
+    pub coverage_dir: Option<String>,
+}
+
 #[derive(Subcommand)]
 pub(crate) enum Commands {
     /// Run a Tish file (interpret)
     Run(RunArgs),
     /// Interactive REPL
     Repl(ReplArgs),
+    /// Run tests (`*.test.tish`, `*.spec.tish`, …)
+    Test(TestArgs),
     /// Build native binary, wasm, wasi, or JavaScript output
     Build(BuildArgs),
     /// Compile a single `.tish` module to one ES module (for Vite dev / HMR); prints to stdout

package/crates/tish/src/main.rs

@@ -74,7 +74,7 @@ fn argv_with_implicit_run(mut argv: Vec<String>) -> Vec<String> {
     if argv.len() >= 2 {
         let first = argv[1].as_str();
         const SUBCOMMANDS: &[&str] =
-            &["run", "repl", "build", "compile-module", "resolve-id", "dump-ast"];
+            &["run", "repl", "test", "build", "compile-module", "resolve-id", "dump-ast"];
         let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.contains(&first);
         if looks_like_file {
             argv.insert(1, "run".to_string());
@@ -120,6 +120,98 @@ fn main() {
             tishlang_core::set_process_argv(argv);
             run_file(&a.file, &a.backend, &a.features, a.no_optimize || no_opt_env)
         }
+        Some(Commands::Test(a)) => {
+            #[cfg(feature = "test-runner")]
+            {
+                use tishlang_test::{run_tests, TestOptions};
+                use tishlang_test::report::ReporterKind;
+
+                let reporter = match a.reporter.as_str() {
+                    "dots" => ReporterKind::Dots,
+                    _ => ReporterKind::Console,
+                };
+                let (roots, filters) = if a.filters.is_empty() {
+                    (vec![std::path::PathBuf::from(".")], Vec::new())
+                } else {
+                    // Path-like args that exist become discovery roots; others are substring filters.
+                    let mut roots = Vec::new();
+                    let mut filters = Vec::new();
+                    for f in &a.filters {
+                        let p = std::path::PathBuf::from(f);
+                        if p.exists() {
+                            roots.push(p);
+                        } else {
+                            filters.push(f.clone());
+                        }
+                    }
+                    if roots.is_empty() {
+                        roots.push(std::path::PathBuf::from("."));
+                    }
+                    (roots, filters)
+                };
+                let shard = a.shard.as_ref().and_then(|s| {
+                    let parts: Vec<_> = s.split('/').collect();
+                    if parts.len() == 2 {
+                        let i = parts[0].parse().ok()?;
+                        let n = parts[1].parse().ok()?;
+                        Some((i, n))
+                    } else {
+                        None
+                    }
+                });
+                let backend = a.backend.as_str();
+                if backend != "vm" {
+                    // The interpreter cannot host test callbacks: its closures are bound to the
+                    // `Evaluator`, which is dropped before the collected suite runs. `--backend
+                    // interp` used to be accepted and then fail on the simplest test file.
+                    let hint = if backend == "interp" {
+                        "`--backend interp` cannot run tests: interpreter closures are bound to the evaluator and cannot be called back after collection"
+                    } else {
+                        "`--backend native` is not implemented yet"
+                    };
+                    eprintln!("error: unsupported --backend `{backend}` for tish test (use `vm`); {hint}");
+                    std::process::exit(2);
+                }
+                let opts = TestOptions {
+                    roots,
+                    filters,
+                    name_pattern: a.test_name_pattern.clone(),
+                    timeout_ms: a.timeout,
+                    bail: a.bail,
+                    retry: a.retry,
+                    update_snapshots: a.update_snapshots,
+                    reporter,
+                    junit_path: a.reporter_outfile.as_ref().map(std::path::PathBuf::from),
+                    only: a.only,
+                    backend: a.backend.clone(),
+                    no_optimize: a.no_optimize || no_opt_env,
+                    features: a.features.clone(),
+                    shard,
+                    randomize: a.randomize || a.seed.is_some(),
+                    seed: a.seed,
+                    rerun_each: a.rerun_each,
+                    tags: a.tags.clone(),
+                    preload: a.preload.iter().map(std::path::PathBuf::from).collect(),
+                    ci: a.ci,
+                    coverage: a.coverage || a.coverage_dir.is_some(),
+                    coverage_dir: a.coverage_dir.as_ref().map(std::path::PathBuf::from),
+                };
+                if a.watch {
+                    let code = tishlang_test::run_tests_watch(opts);
+                    std::process::exit(code);
+                }
+                let result = run_tests(opts);
+                std::process::exit(result.exit_code);
+            }
+            #[cfg(not(feature = "test-runner"))]
+            {
+                let _ = a;
+                Err(
+                    "tish test requires the test-runner feature (included in --features full)"
+                        .into(),
+                )
+            }
+        }
         Some(Commands::Repl(a)) => run_repl(&a.backend, a.no_optimize || no_opt_env, &a.features),
         Some(Commands::Build(a)) => {
             // `--check warn|error` drives the gradual type checker via the same channel as the

package/crates/tish/tests/scope_merge.rs

@@ -108,3 +108,93 @@ fn scope_tish_crate_routes_native() {
         "@scope package with tish.crate must NOT be merged as Tish source"
     );
 }
+
+// ── #587: two modules exporting the SAME name, flattened into one scope ──────────────────────────
+//
+// `isolate_private_top_level_bindings` renamed colliding PRIVATE top-level names but skipped
+// exported ones, on the reasoning that "exported names stay stable so imports keep resolving".
+// `module_exports` is an indirection from export name to source symbol, so that was stricter than
+// necessary — and leaving the collision produced a silently WRONG program rather than a slower one.
+//
+// The barrel pattern is where it bites: `import { greet as _greet }` + a local `export fn greet`
+// that calls `_greet`. Flattened, that emits two `function greet` declarations, and because JS
+// function declarations HOIST, the second overwrote the first BEFORE `const _greet = greet` ran.
+// `_greet` then pointed at the wrapper and the program recursed until the stack blew.
+//
+// The entry module is excluded from renaming on purpose: its exports are the bundle's public
+// surface, so moving those would change the API the caller sees. Only the dep is renamed here.
+
+/// dep exports `greet`; barrel imports it aliased and re-exports its own `greet` wrapper.
+fn setup_barrel() -> tempfile::TempDir {
+    let dir = tempfile::tempdir().unwrap();
+    let root = dir.path();
+    fs::create_dir_all(root.join("dep")).unwrap();
+    fs::create_dir_all(root.join("app")).unwrap();
+    fs::write(
+        root.join("dep/lib.tish"),
+        "export fn greet(name) { return \"hi \" + name }\n",
+    )
+    .unwrap();
+    fs::write(
+        root.join("app/barrel.tish"),
+        "import { greet as _greet } from \"../dep/lib.tish\"\n\
+         export fn greet(name) { return _greet(name) }\n",
+    )
+    .unwrap();
+    fs::write(
+        root.join("main.tish"),
+        "import { greet } from \"./app/barrel.tish\"\nconsole.log(greet(\"world\"))\n",
+    )
+    .unwrap();
+    dir
+}
+
+#[test]
+fn colliding_exported_names_are_isolated_across_modules() {
+    let dir = setup_barrel();
+    let root = dir.path();
+    let modules = resolve_project(&root.join("main.tish"), Some(root)).expect("resolve");
+    let merged = merge_modules(modules).expect("merge");
+
+    // The two `greet` declarations must not both be named `greet` in the flat program — that is the
+    // collision, and on the JS target hoisting silently resolves it the wrong way.
+    let greet_decls: Vec<&str> = merged
+        .program
+        .statements
+        .iter()
+        .filter_map(|s| match s {
+            Statement::FunDecl { name, .. } => Some(name.as_ref()),
+            _ => None,
+        })
+        .filter(|n| n.starts_with("greet"))
+        .collect();
+    assert!(
+        greet_decls.len() >= 2,
+        "expected both modules' greet fns in the merged program, got {:?}",
+        greet_decls
+    );
+    let bare = greet_decls.iter().filter(|n| **n == "greet").count();
+    assert!(
+        bare <= 1,
+        "two top-level `greet` declarations survived the merge — on the JS target the later one \
+         hoists over the former and the barrel's alias captures the wrapper (infinite recursion). \
+         Got {:?}",
+        greet_decls
+    );
+
+    // The alias must bind to the DEP's symbol, not to the local wrapper.
+    let alias_target = merged.program.statements.iter().find_map(|s| match s {
+        Statement::VarDecl {
+            name,
+            init: Some(Expr::Ident { name: src, .. }),
+            ..
+        } if name.as_ref() == "_greet" => Some(src.to_string()),
+        _ => None,
+    });
+    if let Some(target) = alias_target {
+        assert_ne!(
+            target, "greet",
+            "`_greet` must not bind to the ambiguous bare `greet`; it should name the dep's symbol"
+        );
+    }
+}