@tishlang/tish 1.7.0 → 1.9.0

package/crates/tish_compile/src/infer.rs

@@ -135,6 +135,7 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
     match stmt {
         Statement::VarDecl {
             name,
+            name_span,
             mutable,
             type_ann,
             init,
@@ -152,6 +153,7 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
             }
             Statement::VarDecl {
                 name: name.clone(),
+                name_span: *name_span,
                 mutable: *mutable,
                 type_ann: inferred,
                 init: init.clone(),
@@ -189,6 +191,7 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
         }
         Statement::ForOf {
             name,
+            name_span,
             iterable,
             body,
             span,
@@ -198,6 +201,7 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
             ctx.pop_scope();
             Statement::ForOf {
                 name: name.clone(),
+                name_span: *name_span,
                 iterable: iterable.clone(),
                 body: new_body,
                 span: *span,
@@ -243,6 +247,7 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
         Statement::FunDecl {
             async_,
             name,
+            name_span,
             params,
             rest_param,
             return_type,
@@ -267,6 +272,7 @@ fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
             Statement::FunDecl {
                 async_: *async_,
                 name: name.clone(),
+                name_span: *name_span,
                 params: params.clone(),
                 rest_param: rest_param.clone(),
                 return_type: return_type.clone(),

package/crates/tish_compile/src/lib.rs

@@ -16,9 +16,10 @@ pub use resolve::{
     cargo_export_fn_name, compute_native_build_artifacts, detect_cycles, export_name_to_rust_ident,
     extract_native_import_features, format_rust_dependencies_toml, generate_native_wrapper_rs,
     has_external_native_imports, has_native_imports, infer_native_module_exports,
-    is_builtin_native_spec, is_cargo_native_spec, merge_modules, read_project_tish_config,
-    resolve_native_modules, resolve_project, resolve_project_from_stdin, NativeBuildArtifacts,
-    NativeModuleInit, ResolvedNativeModule,
+    is_builtin_native_spec, is_cargo_native_spec, is_native_import, merge_modules,
+    normalize_builtin_spec, read_project_tish_config,
+    resolve_bare_spec, resolve_native_modules, resolve_project, resolve_project_from_stdin,
+    MergedProgram, NativeBuildArtifacts, NativeModuleInit, ResolvedNativeModule,
 };
 pub use types::{RustType, TypeContext};
 

package/crates/tish_compile/src/resolve.rs

@@ -49,6 +49,7 @@ pub struct NativeBuildArtifacts {
 const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("fs", "tish:fs"),
     ("http", "tish:http"),
+    ("timers", "tish:timers"),
     ("process", "tish:process"),
     ("ws", "tish:ws"),
 ];
@@ -66,8 +67,8 @@ pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
 
 /// Built-in modules that come from tishlang_runtime, not from package.json.
 pub fn is_builtin_native_spec(spec: &str) -> bool {
-    matches!(spec, "tish:fs" | "tish:http" | "tish:process" | "tish:ws")
-        || matches!(spec, "fs" | "http" | "process" | "ws")
+    matches!(spec, "tish:fs" | "tish:http" | "tish:timers" | "tish:process" | "tish:ws")
+        || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
 }
 
 /// Resolve all native imports in a merged program via package.json lookup.
@@ -388,7 +389,7 @@ pub fn generate_native_wrapper_rs(
          use std::cell::RefCell;\n\
          use std::rc::Rc;\n\
          use std::sync::Arc;\n\
-         use tishlang_runtime::{ObjectMap, Value};\n\n",
+         use tishlang_runtime::{ObjectMap, Value, VmRef};\n\n",
     );
     let mut any = false;
     for m in modules {
@@ -414,11 +415,11 @@ pub fn generate_native_wrapper_rs(
             let rust_fn = export_name_to_rust_ident(&export_name);
             let key_lit = format!("{:?}", export_name);
             file.push_str(&format!(
-                "    m.insert(Arc::from({}), Value::Function(Rc::new(|args: &[Value]| {{\n        {}::{}(args)\n    }})));\n",
+                "    m.insert(Arc::from({}), Value::native(|args: &[Value]| {{\n        {}::{}(args)\n    }}));\n",
                 key_lit, shim_crate, rust_fn
             ));
         }
-        file.push_str("    Value::Object(Rc::new(RefCell::new(m)))\n}\n\n");
+        file.push_str("    Value::Object(VmRef::new(m))\n}\n\n");
     }
     if !any {
         return String::new();
@@ -719,7 +720,7 @@ fn load_module_recursive(
 }
 
 /// Returns true for native module imports that don't resolve to files.
-/// - fs, http, process, ws (Node-compatible aliases for tish:fs, tish:http, tish:process, tish:ws)
+/// - fs, http, timers, process, ws (Node-compatible aliases for tish:*)
 /// - tish:egui, tish:polars, etc.
 /// - cargo:… (Cargo `rustDependencies` + generated wrapper; Rust native backend)
 /// - @scope/package (npm-style)
@@ -727,7 +728,7 @@ pub fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
         || spec.starts_with('@')
-        || matches!(spec, "fs" | "http" | "process" | "ws")
+        || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
 }
 
 /// Map native spec to Cargo feature name for built-in tish:* modules.
@@ -736,30 +737,52 @@ pub fn native_spec_to_feature(spec: &str) -> Option<String> {
     canonical.strip_prefix("tish:").map(|s| s.to_string())
 }
 
-/// Resolve a bare specifier (e.g. "lattish") to a path via node_modules.
-fn resolve_bare_spec(spec: &str, from_dir: &Path, _project_root: &Path) -> Option<PathBuf> {
+/// Resolve `package.json` at `pkg_root` to the package's main `.tish` entry, if `name` matches `spec`.
+fn resolve_package_root_to_entry(pkg_root: &Path, spec: &str) -> Option<PathBuf> {
+    let pkg_json = pkg_root.join("package.json");
+    if !pkg_json.exists() {
+        return None;
+    }
+    if read_package_name(&pkg_json).as_deref() != Some(spec) {
+        return None;
+    }
+    let content = std::fs::read_to_string(&pkg_json).ok()?;
+    let json: serde_json::Value = serde_json::from_str(&content).ok()?;
+    let entry = json
+        .get("tish")
+        .and_then(|t| t.get("module"))
+        .and_then(|m| m.as_str())
+        .or_else(|| json.get("main").and_then(|m| m.as_str()))
+        .unwrap_or("index.tish");
+    let entry_clean = entry.trim_start_matches("./");
+    let resolved = pkg_root.join(entry_clean);
+    if !resolved.exists() {
+        return None;
+    }
+    match resolved.canonicalize() {
+        Ok(p) => Some(p),
+        Err(_) => Some(resolved),
+    }
+}
+
+/// Resolve a bare specifier (e.g. "lattish") to the package entry `.tish` file.
+///
+/// Walks upward from `from_dir` and, at each level, checks (same order as native [`find_package_dir`]):
+/// - `node_modules/<spec>/`
+/// - `<spec>/` as a sibling directory (monorepo: `…/tish/tish-candle` next to `…/tish/tish-hub`)
+/// - the search directory itself if its `package.json` name matches `spec`
+pub fn resolve_bare_spec(spec: &str, from_dir: &Path, _project_root: &Path) -> Option<PathBuf> {
     let mut search = from_dir.to_path_buf();
     loop {
-        let node_mod = search.join("node_modules").join(spec);
-        let pkg_json = node_mod.join("package.json");
-        if pkg_json.exists() {
-            if let Some(name) = read_package_name(&pkg_json) {
-                if name == spec {
-                    let content = std::fs::read_to_string(&pkg_json).ok()?;
-                    let json: serde_json::Value = serde_json::from_str(&content).ok()?;
-                    let entry = json
-                        .get("tish")
-                        .and_then(|t| t.get("module"))
-                        .and_then(|m| m.as_str())
-                        .or_else(|| json.get("main").and_then(|m| m.as_str()));
-                    let entry = entry.unwrap_or("index.tish");
-                    let entry_clean = entry.trim_start_matches("./");
-                    let resolved = node_mod.join(entry_clean);
-                    if resolved.exists() {
-                        return resolved.canonicalize().ok();
-                    }
-                }
-            }
+        if let Some(p) = resolve_package_root_to_entry(&search.join("node_modules").join(spec), spec)
+        {
+            return Some(p);
+        }
+        if let Some(p) = resolve_package_root_to_entry(&search.join(spec), spec) {
+            return Some(p);
+        }
+        if let Some(p) = resolve_package_root_to_entry(&search, spec) {
+            return Some(p);
         }
         if let Some(parent) = search.parent() {
             if parent == search {
@@ -790,7 +813,7 @@ fn resolve_import_path(
             return Ok(path);
         }
         return Err(format!(
-            "Package '{}' not found in node_modules. Install it with: npm install {}",
+            "Package '{}' not found. Install with `npm install {}`, or place the package under node_modules/ or as a sibling directory (same layout as native `find_package_dir`).",
             spec, spec
         ));
     }
@@ -885,10 +908,27 @@ fn has_cycle_from(
     Ok(false)
 }
 
+/// Result of [`merge_modules`]: merged AST plus, per top-level statement, the originating `.tish` file.
+#[derive(Debug)]
+pub struct MergedProgram {
+    pub program: Program,
+    pub statement_sources: Vec<PathBuf>,
+}
+
+fn merge_push(
+    statements: &mut Vec<Statement>,
+    statement_sources: &mut Vec<PathBuf>,
+    stmt: Statement,
+    source: PathBuf,
+) {
+    statements.push(stmt);
+    statement_sources.push(source);
+}
+
 /// Merge all resolved modules into a single program. Dependencies are emitted first.
 /// Import statements are rewritten as bindings from already-emitted dep exports.
 /// Export statements are unwrapped (the inner declaration is emitted).
-pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
+pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<MergedProgram, String> {
     let path_to_idx: HashMap<PathBuf, usize> = modules
         .iter()
         .enumerate()
@@ -919,7 +959,9 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
     }
 
     let mut statements = Vec::new();
+    let mut statement_sources = Vec::new();
     for (idx, module) in modules.iter().enumerate() {
+        let src_path = module.path.clone();
         let dir = module.path.parent().unwrap_or(Path::new("."));
         for stmt in &module.program.statements {
             match stmt {
@@ -935,32 +977,44 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                         // Emit VarDecl with NativeModuleLoad for each specifier
                         for spec in specifiers {
                             match spec {
-                                ImportSpecifier::Named { name, alias } => {
+                                ImportSpecifier::Named {
+                                    name,
+                                    name_span,
+                                    alias,
+                                    alias_span,
+                                } => {
                                     let bind = alias.as_deref().unwrap_or(name.as_ref());
+                                    let decl_name_span = alias_span.as_ref().unwrap_or(name_span);
                                     let init = Expr::NativeModuleLoad {
                                         spec: Arc::from(canonical_spec.clone()),
                                         export_name: name.clone(),
                                         span: *span,
                                     };
-                                    statements.push(Statement::VarDecl {
-                                        name: Arc::from(bind),
-                                        mutable: false,
-                                        type_ann: None,
-                                        init: Some(init),
-                                        span: *span,
-                                    });
+                                    merge_push(
+                                        &mut statements,
+                                        &mut statement_sources,
+                                        Statement::VarDecl {
+                                            name: Arc::from(bind),
+                                            name_span: *decl_name_span,
+                                            mutable: false,
+                                            type_ann: None,
+                                            init: Some(init),
+                                            span: *span,
+                                        },
+                                        src_path.clone(),
+                                    );
                                 }
-                                ImportSpecifier::Namespace(ns) => {
+                                ImportSpecifier::Namespace { name, .. } => {
                                     return Err(format!(
                                         "Namespace import (* as {}) not supported for native module '{}'",
-                                        ns.as_ref(),
+                                        name.as_ref(),
                                         from.as_ref()
                                     ));
                                 }
-                                ImportSpecifier::Default(bind) => {
+                                ImportSpecifier::Default { name, .. } => {
                                     return Err(format!(
                                         "Default import '{}' not supported for native module '{}'. Use named import, e.g. import {{ egui }} from '{}'",
-                                        bind.as_ref(),
+                                        name.as_ref(),
                                         from.as_ref(),
                                         from.as_ref()
                                     ));
@@ -977,26 +1031,38 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                     let dep_exports = &module_exports[dep_idx];
                     for spec in specifiers {
                         match spec {
-                            ImportSpecifier::Named { name, alias } => {
+                            ImportSpecifier::Named {
+                                name,
+                                name_span,
+                                alias,
+                                alias_span,
+                            } => {
                                 let source = dep_exports
                                     .get(name.as_ref())
                                     .cloned()
                                     .unwrap_or_else(|| name.to_string());
                                 let bind = alias.as_deref().unwrap_or(name.as_ref());
                                 if bind != source {
-                                    statements.push(Statement::VarDecl {
-                                        name: Arc::from(bind),
-                                        mutable: false,
-                                        type_ann: None,
-                                        init: Some(Expr::Ident {
-                                            name: Arc::from(source),
+                                    let decl_name_span = alias_span.as_ref().unwrap_or(name_span);
+                                    merge_push(
+                                        &mut statements,
+                                        &mut statement_sources,
+                                        Statement::VarDecl {
+                                            name: Arc::from(bind),
+                                            name_span: *decl_name_span,
+                                            mutable: false,
+                                            type_ann: None,
+                                            init: Some(Expr::Ident {
+                                                name: Arc::from(source),
+                                                span: *span,
+                                            }),
                                             span: *span,
-                                        }),
-                                        span: *span,
-                                    });
+                                        },
+                                        src_path.clone(),
+                                    );
                                 }
                             }
-                            ImportSpecifier::Namespace(ns) => {
+                            ImportSpecifier::Namespace { name, name_span } => {
                                 let mut props = Vec::new();
                                 for (k, v) in dep_exports {
                                     props.push(tishlang_ast::ObjectProp::KeyValue(
@@ -1007,51 +1073,83 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                                         },
                                     ));
                                 }
-                                statements.push(Statement::VarDecl {
-                                    name: ns.clone(),
-                                    mutable: false,
-                                    type_ann: None,
-                                    init: Some(Expr::Object { props, span: *span }),
-                                    span: *span,
-                                });
+                                merge_push(
+                                    &mut statements,
+                                    &mut statement_sources,
+                                    Statement::VarDecl {
+                                        name: name.clone(),
+                                        name_span: *name_span,
+                                        mutable: false,
+                                        type_ann: None,
+                                        init: Some(Expr::Object { props, span: *span }),
+                                        span: *span,
+                                    },
+                                    src_path.clone(),
+                                );
                             }
-                            ImportSpecifier::Default(bind) => {
+                            ImportSpecifier::Default { name, name_span } => {
                                 let source =
                                     dep_exports.get("default").cloned().ok_or_else(|| {
                                         format!("Module '{}' has no default export", from)
                                     })?;
-                                statements.push(Statement::VarDecl {
-                                    name: bind.clone(),
-                                    mutable: false,
-                                    type_ann: None,
-                                    init: Some(Expr::Ident {
-                                        name: Arc::from(source),
+                                merge_push(
+                                    &mut statements,
+                                    &mut statement_sources,
+                                    Statement::VarDecl {
+                                        name: name.clone(),
+                                        name_span: *name_span,
+                                        mutable: false,
+                                        type_ann: None,
+                                        init: Some(Expr::Ident {
+                                            name: Arc::from(source),
+                                            span: *span,
+                                        }),
                                         span: *span,
-                                    }),
-                                    span: *span,
-                                });
+                                    },
+                                    src_path.clone(),
+                                );
                             }
                         }
                     }
                 }
                 Statement::Export { declaration, .. } => match declaration.as_ref() {
-                    ExportDeclaration::Named(s) => statements.push(*s.clone()),
+                    ExportDeclaration::Named(s) => merge_push(
+                        &mut statements,
+                        &mut statement_sources,
+                        *s.clone(),
+                        src_path.clone(),
+                    ),
                     ExportDeclaration::Default(e) => {
                         let default_name = format!("__default_{}", idx);
-                        statements.push(Statement::VarDecl {
-                            name: Arc::from(default_name),
-                            mutable: false,
-                            type_ann: None,
-                            init: Some((*e).clone()),
-                            span: e.span(),
-                        });
+                        let espan = e.span();
+                        merge_push(
+                            &mut statements,
+                            &mut statement_sources,
+                            Statement::VarDecl {
+                                name: Arc::from(default_name),
+                                name_span: espan,
+                                mutable: false,
+                                type_ann: None,
+                                init: Some((*e).clone()),
+                                span: espan,
+                            },
+                            src_path.clone(),
+                        );
                     }
                 },
-                _ => statements.push(stmt.clone()),
+                _ => merge_push(
+                    &mut statements,
+                    &mut statement_sources,
+                    stmt.clone(),
+                    src_path.clone(),
+                ),
             }
         }
     }
-    Ok(Program { statements })
+    Ok(MergedProgram {
+        program: Program { statements },
+        statement_sources,
+    })
 }
 
 #[cfg(test)]
@@ -1088,7 +1186,7 @@ mod cargo_spec_tests {
         std::fs::write(&p, src).unwrap();
         let root = dir.path();
         let modules = resolve_project(&p, Some(root)).unwrap();
-        merge_modules(modules).unwrap();
+        let _ = merge_modules(modules).unwrap();
     }
 
     #[test]