@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish/src/main.rs

@@ -1,9 +1,11 @@
 //! Tish CLI - run, REPL, build to native or other targets.
 
+mod cargo_native_registry;
 mod cli_help;
 mod repl_completion;
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::collections::HashSet;
 use std::fs;
 use std::io::{self, IsTerminal, Read, Write};
@@ -15,13 +17,13 @@ use rustyline::{Behavior, ColorMode, CompletionType, Config, Editor};
 
 use cli_help::{Cli, Commands};
 
-/// Normalize `--feature` / `--feature http,fs` / `--feature full` for VM runs and native builds.
+/// Normalize `--feature` / `--feature http,timers,fs` / `--feature full` for VM runs and native builds.
 fn normalize_capability_flags(features: &[String]) -> HashSet<String> {
     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", "fs", "process", "regex", "ws"] {
+                for name in ["http", "timers", "fs", "process", "regex", "ws"] {
                     out.insert(name.to_string());
                 }
             } else {
@@ -48,7 +50,9 @@ fn vm_capabilities_for_cli_run(cli_features: &[String]) -> HashSet<String> {
 /// `--feature` list for `tish build --target native`: same default as `tish run` (all linked-in caps).
 fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
     if cli_features.is_empty() {
-        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities().into_iter().collect();
+        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
+            .into_iter()
+            .collect();
         v.sort();
         v
     } else {
@@ -61,8 +65,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", "dump-ast"];
-        let looks_like_file =
-            !first.starts_with('-') && !SUBCOMMANDS.iter().any(|&s| s == first);
+        let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.iter().any(|&s| s == first);
         if looks_like_file {
             argv.insert(1, "run".to_string());
         }
@@ -95,7 +98,12 @@ fn main() {
     let matches = cli_help::build_command().get_matches_from(&argv);
     let cli = Cli::from_arg_matches(&matches).unwrap_or_else(|e| e.exit());
     let result = match cli.command {
-        Some(Commands::Run(a)) => run_file(&a.file, &a.backend, &a.features, a.no_optimize || no_opt_env),
+        Some(Commands::Run(a)) => run_file(
+            &a.file,
+            &a.backend,
+            &a.features,
+            a.no_optimize || no_opt_env,
+        ),
         Some(Commands::Repl(a)) => run_repl(&a.backend, a.no_optimize || no_opt_env, &a.features),
         Some(Commands::Build(a)) => build_file(
             &a.file,
@@ -104,6 +112,7 @@ fn main() {
             &a.native_backend,
             &a.features,
             a.no_optimize || no_opt_env,
+            a.source_map,
         ),
         Some(Commands::DumpAst { file }) => dump_ast(&file),
         None => {
@@ -136,7 +145,8 @@ fn run_stdin_pipe(
     if source.trim().is_empty() {
         if fail_on_empty {
             return Err(
-                "No source on stdin. Example: echo 'console.log(1)' | tish   or   tish run -".into(),
+                "No source on stdin. Example: echo 'console.log(1)' | tish   or   tish run -"
+                    .into(),
             );
         }
         return Ok(());
@@ -153,7 +163,7 @@ fn run_stdin_source(
     let cwd = std::env::current_dir().map_err(|e| e.to_string())?;
     let modules = tishlang_compile::resolve_project_from_stdin(source, &cwd)?;
     tishlang_compile::detect_cycles(&modules)?;
-    let prog = tishlang_compile::merge_modules(modules)?;
+    let prog = tishlang_compile::merge_modules(modules)?.program;
     let program = if no_optimize {
         prog
     } else {
@@ -162,12 +172,18 @@ fn run_stdin_source(
     run_program(&program, backend, no_optimize, features)
 }
 
-fn run_file(path: &str, backend: &str, features: &[String], no_optimize: bool) -> Result<(), String> {
+fn run_file(
+    path: &str,
+    backend: &str,
+    features: &[String],
+    no_optimize: bool,
+) -> Result<(), String> {
     let program = if path == "-" {
         return run_stdin_pipe(backend, features, no_optimize, true);
     } else {
-        let path =
-            Path::new(path).canonicalize().map_err(|e| format!("Cannot resolve {}: {}", path, e))?;
+        let path = Path::new(path)
+            .canonicalize()
+            .map_err(|e| format!("Cannot resolve {}: {}", path, e))?;
         let project_root = path.parent().and_then(|p| {
             if p.file_name().and_then(|n| n.to_str()) == Some("src") {
                 p.parent()
@@ -177,8 +193,10 @@ fn run_file(path: &str, backend: &str, features: &[String], no_optimize: bool) -
         });
 
         if path.extension().map(|e| e == "js") == Some(true) {
-            let prog = tishlang_js_to_tish::convert(&fs::read_to_string(&path).map_err(|e| format!("{}", e))?)
-                .map_err(|e| format!("{}", e))?;
+            let prog = tishlang_js_to_tish::convert(
+                &fs::read_to_string(&path).map_err(|e| format!("{}", e))?,
+            )
+            .map_err(|e| format!("{}", e))?;
             if no_optimize {
                 prog
             } else {
@@ -187,7 +205,7 @@ fn run_file(path: &str, backend: &str, features: &[String], no_optimize: bool) -
         } else {
             let modules = tishlang_compile::resolve_project(&path, project_root)?;
             tishlang_compile::detect_cycles(&modules)?;
-            let prog = tishlang_compile::merge_modules(modules)?;
+            let prog = tishlang_compile::merge_modules(modules)?.program;
             if no_optimize {
                 prog
             } else {
@@ -208,8 +226,18 @@ fn run_program(
     if backend == "interp" {
         let mut eval = tishlang_eval::Evaluator::new();
         let value = eval.eval_program(program)?;
+        #[cfg(feature = "timers")]
+        {
+            let _ = eval.run_timer_phase();
+        }
         if !matches!(value, tishlang_eval::Value::Null) {
-            println!("{}", tishlang_eval::format_value_for_console(&value, tishlang_core::use_console_colors()));
+            println!(
+                "{}",
+                tishlang_eval::format_value_for_console(
+                    &value,
+                    tishlang_core::use_console_colors()
+                )
+            );
         }
         return Ok(());
     }
@@ -220,15 +248,14 @@ fn run_program(
         tishlang_bytecode::compile(program).map_err(|e| e.to_string())?
     };
     let caps = vm_capabilities_for_cli_run(features);
-    let value = tishlang_vm::run_with_options(
-        &chunk,
-        tishlang_vm::VmRunOptions {
-            repl_mode: false,
-            capabilities: caps,
-        },
-    )?;
+    let mut vm = tishlang_vm::Vm::with_capabilities(caps);
+    cargo_native_registry::register_bytecode_native_modules(&mut vm);
+    let value = vm.run_with_options(&chunk, false)?;
     if !matches!(value, tishlang_core::Value::Null) {
-        println!("{}", tishlang_core::format_value_styled(&value, tishlang_core::use_console_colors()));
+        println!(
+            "{}",
+            tishlang_core::format_value_styled(&value, tishlang_core::use_console_colors())
+        );
     }
     Ok(())
 }
@@ -246,7 +273,11 @@ fn run_repl(backend: &str, no_optimize: bool, features: &[String]) -> Result<(),
             print!("{}", prompt);
             io::stdout().flush().map_err(|e| e.to_string())?;
             buffer.clear();
-            if io::stdin().read_line(&mut buffer).map_err(|e| e.to_string())? == 0 {
+            if io::stdin()
+                .read_line(&mut buffer)
+                .map_err(|e| e.to_string())?
+                == 0
+            {
                 if !multiline.is_empty() {
                     let _ = tishlang_parser::parse(multiline.trim());
                 }
@@ -266,8 +297,18 @@ fn run_repl(backend: &str, no_optimize: bool, features: &[String]) -> Result<(),
                 Ok(program) => {
                     match eval.eval_program(&program) {
                         Ok(v) => {
+                            #[cfg(feature = "timers")]
+                            {
+                                let _ = eval.run_timer_phase();
+                            }
                             if !matches!(v, tishlang_eval::Value::Null) {
-                                println!("{}", tishlang_eval::format_value_for_console(&v, tishlang_core::use_console_colors()));
+                                println!(
+                                    "{}",
+                                    tishlang_eval::format_value_for_console(
+                                        &v,
+                                        tishlang_core::use_console_colors()
+                                    )
+                                );
                             }
                         }
                         Err(e) => eprintln!("{}", e),
@@ -291,11 +332,11 @@ fn run_repl(backend: &str, no_optimize: bool, features: &[String]) -> Result<(),
     if !std::io::stdin().is_terminal() {
         eprintln!("Note: Tab completion and grey preview require an interactive terminal (TTY).");
     }
-    let vm = Rc::new(RefCell::new(tishlang_vm::Vm::with_capabilities(
-        vm_capabilities_for_cli_run(features),
-    )));
+    let mut vm0 = tishlang_vm::Vm::with_capabilities(vm_capabilities_for_cli_run(features));
+    cargo_native_registry::register_bytecode_native_modules(&mut vm0);
+    let vm = VmRef::new(vm0);
     let completer = repl_completion::ReplCompleter {
-        vm: Rc::clone(&vm),
+        vm: vm.clone(),
         no_optimize,
     };
     let config = Config::builder()
@@ -364,16 +405,20 @@ fn run_repl(backend: &str, no_optimize: bool, features: &[String]) -> Result<(),
                     tishlang_bytecode::compile_for_repl
                 };
                 match compile_fn(&program) {
-                    Ok(chunk) => {
-                        match vm.borrow_mut().run_with_options(&chunk, true) {
-                            Ok(v) => {
-                                if !matches!(v, tishlang_core::Value::Null) {
-                                    println!("{}", tishlang_core::format_value_styled(&v, tishlang_core::use_console_colors()));
-                                }
+                    Ok(chunk) => match vm.borrow_mut().run_with_options(&chunk, true) {
+                        Ok(v) => {
+                            if !matches!(v, tishlang_core::Value::Null) {
+                                println!(
+                                    "{}",
+                                    tishlang_core::format_value_styled(
+                                        &v,
+                                        tishlang_core::use_console_colors()
+                                    )
+                                );
                             }
-                            Err(e) => eprintln!("{}", e),
                         }
-                    }
+                        Err(e) => eprintln!("{}", e),
+                    },
                     Err(e) => eprintln!("Compile error: {}", e),
                 }
                 let _ = rl.add_history_entry(buffer.trim());
@@ -413,12 +458,31 @@ fn repl_prompt(primary: bool) -> String {
 
 /// Path to REPL history file (Python-style: ~/.tish_history).
 fn tish_history_path() -> Option<PathBuf> {
-    let home = std::env::var_os("HOME")
-        .or_else(|| std::env::var_os("USERPROFILE"));
+    let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE"));
     home.map(|h| PathBuf::from(h).join(".tish_history"))
 }
 
-fn compile_to_js(input_path: &Path, output_path: &str, optimize: bool) -> Result<(), String> {
+fn compile_to_js(
+    input_path: &Path,
+    output_path: &str,
+    optimize: bool,
+    source_map: bool,
+) -> Result<(), String> {
+    if source_map && optimize {
+        return Err(
+            "tish build --target js --source-map requires --no-optimize (mappings follow unmerged statement order)."
+                .into(),
+        );
+    }
+    if source_map
+        && (input_path.extension().map(|e| e == "jsx") == Some(true)
+            || input_path.extension().map(|e| e == "js") == Some(true))
+    {
+        return Err(
+            "tish build --target js --source-map is only supported for .tish project builds (not single-file .jsx / .js inputs)."
+                .into(),
+        );
+    }
     let project_root = input_path.parent().and_then(|p| {
         if p.file_name().and_then(|n| n.to_str()) == Some("src") {
             p.parent()
@@ -426,43 +490,70 @@ fn compile_to_js(input_path: &Path, output_path: &str, optimize: bool) -> Result
             Some(p)
         }
     });
-    let js = if input_path.extension().map(|e| e == "jsx") == Some(true) {
+    let out_path = Path::new(output_path);
+    let out_path = if out_path.extension().is_none()
+        || out_path.extension() == Some(std::ffi::OsStr::new(""))
+    {
+        out_path.with_extension("js")
+    } else {
+        out_path.to_path_buf()
+    };
+    let out_js_name = out_path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("out.js");
+
+    let (js, map_json) = if input_path.extension().map(|e| e == "jsx") == Some(true) {
         let source = fs::read_to_string(input_path).map_err(|e| format!("{}", e))?;
         let wrapped = format!(
             "export fn __TishJsxRoot() {{\n  return (\n{}\n  )\n}}",
             source.trim()
         );
-        let program = tishlang_parser::parse(&wrapped)
-            .map_err(|e| format!("JSX wrapper parse: {}", e))?;
+        let program =
+            tishlang_parser::parse(&wrapped).map_err(|e| format!("JSX wrapper parse: {}", e))?;
         let p = if optimize {
             tishlang_opt::optimize(&program)
         } else {
             program
         };
-        tishlang_compile_js::compile_with_jsx(&p, optimize).map_err(|e| format!("{}", e))?
+        let js = tishlang_compile_js::compile_with_jsx(&p, optimize).map_err(|e| format!("{}", e))?;
+        (js, None)
     } else if input_path.extension().map(|e| e == "js") == Some(true) {
         let source = fs::read_to_string(input_path).map_err(|e| format!("{}", e))?;
         let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        tishlang_compile_js::compile_with_jsx(&program, optimize).map_err(|e| format!("{}", e))?
-    } else {
-        tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize)
-            .map_err(|e| format!("{}", e))?
-    };
-
-    let out_path = Path::new(output_path);
-    let out_path = if out_path.extension().is_none()
-        || out_path.extension() == Some(std::ffi::OsStr::new(""))
-    {
-        out_path.with_extension("js")
+        let js =
+            tishlang_compile_js::compile_with_jsx(&program, optimize).map_err(|e| format!("{}", e))?;
+        (js, None)
+    } else if source_map {
+        let bundle = tishlang_compile_js::compile_project_with_jsx_and_source_map(
+            input_path,
+            project_root,
+            out_js_name,
+        )
+        .map_err(|e| format!("{}", e))?;
+        (bundle.js, bundle.source_map_json)
     } else {
-        out_path.to_path_buf()
+        let js = tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize)
+            .map_err(|e| format!("{}", e))?;
+        (js, None)
     };
 
     if let Some(parent) = out_path.parent() {
         fs::create_dir_all(parent)
             .map_err(|e| format!("Cannot create output directory {}: {}", parent.display(), e))?;
     }
-    fs::write(&out_path, js).map_err(|e| format!("Cannot write {}: {}", out_path.display(), e))?;
+    let mut js_out = js;
+    if let Some(map) = &map_json {
+        let map_path = out_path.with_extension("js.map");
+        fs::write(&map_path, map).map_err(|e| format!("Cannot write {}: {}", map_path.display(), e))?;
+        let map_url = map_path
+            .file_name()
+            .and_then(|s| s.to_str())
+            .unwrap_or("out.js.map");
+        js_out.push_str(&format!("\n//# sourceMappingURL={map_url}\n"));
+        println!("Built: {}", map_path.display());
+    }
+    fs::write(&out_path, js_out).map_err(|e| format!("Cannot write {}: {}", out_path.display(), e))?;
     println!("Built: {}", out_path.display());
     Ok(())
 }
@@ -475,15 +566,17 @@ fn build_file(
     native_backend: &str,
     cli_features: &[String],
     no_optimize: bool,
+    source_map: bool,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
-    let input_path =
-        Path::new(input_path).canonicalize().map_err(|e| format!("Cannot resolve {}: {}", input_path, e))?;
+    let input_path = Path::new(input_path)
+        .canonicalize()
+        .map_err(|e| format!("Cannot resolve {}: {}", input_path, e))?;
 
     let is_js = input_path.extension().map(|e| e == "js") == Some(true);
 
     if target == "js" {
-        return compile_to_js(&input_path, output_path, optimize);
+        return compile_to_js(&input_path, output_path, optimize, source_map);
     }
 
     if target == "wasm" && is_js {
@@ -501,8 +594,13 @@ fn build_file(
                 Some(p)
             }
         });
-        return tishlang_wasm::compile_to_wasm(&input_path, project_root, Path::new(output_path), optimize)
-            .map_err(|e| e.to_string());
+        return tishlang_wasm::compile_to_wasm(
+            &input_path,
+            project_root,
+            Path::new(output_path),
+            optimize,
+        )
+        .map_err(|e| e.to_string());
     }
 
     if target == "wasi" {
@@ -513,8 +611,13 @@ fn build_file(
                 Some(p)
             }
         });
-        return tishlang_wasm::compile_to_wasi(&input_path, project_root, Path::new(output_path), optimize)
-            .map_err(|e| e.to_string());
+        return tishlang_wasm::compile_to_wasi(
+            &input_path,
+            project_root,
+            Path::new(output_path),
+            optimize,
+        )
+        .map_err(|e| e.to_string());
     }
 
     if target != "native" {
@@ -570,8 +673,6 @@ fn build_file(
     Ok(())
 }
 
-
-
 #[cfg(test)]
 mod cli_tests {
     use clap::Parser;
@@ -582,10 +683,7 @@ mod cli_tests {
 
     #[test]
     fn implicit_run_inserts_run_before_file() {
-        let argv = argv_with_implicit_run(vec![
-            "tish".to_string(),
-            "hello.tish".to_string(),
-        ]);
+        let argv = argv_with_implicit_run(vec!["tish".to_string(), "hello.tish".to_string()]);
         let cli = Cli::try_parse_from(argv).unwrap();
         match cli.command {
             Some(Commands::Run(a)) => assert_eq!(a.file, "hello.tish"),
@@ -595,26 +693,15 @@ mod cli_tests {
 
     #[test]
     fn explicit_subcommand_not_treated_as_file() {
-        let argv = argv_with_implicit_run(vec![
-            "tish".to_string(),
-            "repl".to_string(),
-        ]);
+        let argv = argv_with_implicit_run(vec!["tish".to_string(), "repl".to_string()]);
         let cli = Cli::try_parse_from(argv).unwrap();
         assert!(matches!(cli.command, Some(Commands::Repl(_))));
     }
 
     #[test]
     fn build_js_target_parses() {
-        let cli = Cli::try_parse_from([
-            "tish",
-            "build",
-            "m.tish",
-            "--target",
-            "js",
-            "-o",
-            "x.js",
-        ])
-        .unwrap();
+        let cli = Cli::try_parse_from(["tish", "build", "m.tish", "--target", "js", "-o", "x.js"])
+            .unwrap();
         match cli.command {
             Some(Commands::Build(a)) => assert_eq!(a.file, "m.tish"),
             _ => panic!("expected Build"),
@@ -632,8 +719,7 @@ mod cli_tests {
 }
 
 fn dump_ast(path: &str) -> Result<(), String> {
-    let source =
-        fs::read_to_string(path).map_err(|e| format!("Cannot read {}: {}", path, e))?;
+    let source = fs::read_to_string(path).map_err(|e| format!("Cannot read {}: {}", path, e))?;
     let program = tishlang_parser::parse(&source)?;
     println!("{:#?}", program);
     Ok(())

package/crates/tish/src/repl_completion.rs

@@ -2,8 +2,8 @@
 //! Grey preview hint below the line (like Node) and Tab for full list.
 
 use std::borrow::Cow;
-use std::cell::RefCell;
-use std::rc::Rc;
+
+use tishlang_core::VmRef;
 
 use rustyline::completion::{Completer, Pair};
 use rustyline::highlight::Highlighter;
@@ -29,7 +29,7 @@ const ANSI_RESET: &str = "\x1b[0m";
 
 /// Tab completer that evaluates the expression before the last `.` and suggests property/method names.
 pub struct ReplCompleter {
-    pub vm: Rc<RefCell<Vm>>,
+    pub vm: VmRef<Vm>,
     pub no_optimize: bool,
 }
 

package/crates/tish/tests/cargo_example_compile.rs

@@ -8,7 +8,9 @@ use tishlang_compile::{compile_project_full, merge_modules, resolve_project};
 
 fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
     if cli_features.is_empty() {
-        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities().into_iter().collect();
+        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
+            .into_iter()
+            .collect();
         v.sort();
         v
     } else {
@@ -37,7 +39,7 @@ fn resolve_and_merge_cargo_example_fixture() {
         panic!("expected import, got {:?}", first);
     };
     assert_eq!(from.as_ref(), "cargo:demo_shim");
-    merge_modules(modules).unwrap();
+    let _ = merge_modules(modules).unwrap();
 }
 
 #[test]