@tishlang/tish 1.9.2 → 1.12.0

package/crates/tish_compile/src/lib.rs

@@ -7,17 +7,27 @@ mod infer;
 mod resolve;
 mod types;
 
+/// How generated Rust is linked (desktop binary vs embedded iOS staticlib).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum NativeEmitMode {
+    #[default]
+    DesktopBin,
+    /// `[lib] crate-type = ["staticlib"]` — no `fn main()`, host calls `tish_ios_launch`.
+    EmbeddedLib,
+}
+
 pub use codegen::CompileError;
 pub use codegen::{
-    compile, compile_project, compile_project_full, compile_with_features,
-    compile_with_native_modules, compile_with_project_root,
+    compile, compile_project, compile_project_full, compile_project_full_emit,
+    compile_with_features, compile_with_native_modules, compile_with_native_modules_emit,
+    compile_with_project_root,
 };
 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, is_native_import, merge_modules,
-    normalize_builtin_spec, read_project_tish_config,
+    cargo_export_fn_name, compute_native_build_artifacts, detect_cycles, ensure_tish_canvas_module,
+    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, is_native_import,
+    merge_modules, normalize_builtin_spec, program_uses_document, read_project_tish_config,
     resolve_bare_spec, resolve_native_modules, resolve_project, resolve_project_from_stdin,
     MergedProgram, NativeBuildArtifacts, NativeModuleInit, ResolvedNativeModule,
 };
@@ -106,6 +116,28 @@ fn factory() {
         );
     }
 
+    /// `value_call` must take `&Value` to a **local** (`let _callee = (<expr>).clone(); … &_callee`):
+    /// `&<temporary>` can dangle in release, and `let _callee = <ident>` would move globals like `Symbol`.
+    #[test]
+    fn native_emit_value_call_materializes_callee() {
+        use std::path::PathBuf;
+        let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        let path = manifest.join("../../tests/core/symbol.tish").canonicalize().unwrap();
+        let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+        assert!(
+            rust.contains("let _callee = (tishlang_runtime::get_index"),
+            "fixture should bracket-call via get_index with callee stored in a local"
+        );
+        assert!(
+            !rust.contains("let _callee = &tishlang_runtime::get_index"),
+            "expected callee materialization, found reference-to-temporary pattern"
+        );
+        assert!(
+            rust.contains("tishlang_runtime::value_call"),
+            "expected value_call via runtime re-export for nested Cargo builds"
+        );
+    }
+
     #[test]
     fn loop_var_decl_clone_via_project_full() {
         // With the inference pass, `let outerVar = 42` is inferred as f64 (Copy) — no clone needed.

package/crates/tish_compile/src/resolve.rs

@@ -4,7 +4,7 @@
 use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-use tishlang_ast::{ExportDeclaration, Expr, ImportSpecifier, Program, Statement};
+use tishlang_ast::{ExportDeclaration, Expr, ImportSpecifier, MemberProp, Program, Statement, CallArg};
 
 /// Resolved native module: crate path and init expression.
 #[derive(Debug, Clone)]
@@ -67,8 +67,10 @@ 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:timers" | "tish:process" | "tish:ws")
-        || matches!(spec, "fs" | "http" | "timers" | "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.
@@ -112,6 +114,188 @@ pub fn resolve_native_modules(
     Ok(modules)
 }
 
+/// True when merged Tish source references the browser global `document` (e.g. juke-cards).
+pub fn program_uses_document(program: &Program) -> bool {
+    use tishlang_ast::{ArrayElement, ArrowBody, JsxAttrValue, JsxChild, JsxProp, ObjectProp};
+
+    fn expr_uses_document(e: &Expr) -> bool {
+        match e {
+            Expr::Ident { name, .. } => name.as_ref() == "document",
+            Expr::Literal { .. } | Expr::NativeModuleLoad { .. } => false,
+            Expr::Binary { left, right, .. } => {
+                expr_uses_document(left) || expr_uses_document(right)
+            }
+            Expr::Unary { operand, .. } | Expr::TypeOf { operand, .. } => {
+                expr_uses_document(operand)
+            }
+            Expr::Call { callee, args, .. } => {
+                expr_uses_document(callee)
+                    || args.iter().any(|a| match a {
+                        CallArg::Expr(e) | CallArg::Spread(e) => expr_uses_document(e),
+                    })
+            }
+            Expr::New { callee, args, .. } => {
+                expr_uses_document(callee)
+                    || args.iter().any(|a| match a {
+                        CallArg::Expr(e) | CallArg::Spread(e) => expr_uses_document(e),
+                    })
+            }
+            Expr::Member { object, prop, .. } => {
+                expr_uses_document(object)
+                    || if let MemberProp::Expr(e) = prop {
+                        expr_uses_document(e)
+                    } else {
+                        false
+                    }
+            }
+            Expr::Index { object, index, .. } => {
+                expr_uses_document(object) || expr_uses_document(index)
+            }
+            Expr::Conditional {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
+                expr_uses_document(cond)
+                    || expr_uses_document(then_branch)
+                    || expr_uses_document(else_branch)
+            }
+            Expr::NullishCoalesce { left, right, .. } => {
+                expr_uses_document(left) || expr_uses_document(right)
+            }
+            Expr::Array { elements, .. } => elements.iter().any(|el| match el {
+                ArrayElement::Expr(e) | ArrayElement::Spread(e) => expr_uses_document(e),
+            }),
+            Expr::Object { props, .. } => props.iter().any(|p| match p {
+                ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => expr_uses_document(e),
+            }),
+            Expr::Assign { value, .. }
+            | Expr::CompoundAssign { value, .. }
+            | Expr::LogicalAssign { value, .. }
+            | Expr::MemberAssign { value, .. }
+            | Expr::IndexAssign { value, .. } => expr_uses_document(value),
+            Expr::PostfixInc { .. }
+            | Expr::PostfixDec { .. }
+            | Expr::PrefixInc { .. }
+            | Expr::PrefixDec { .. } => false,
+            Expr::ArrowFunction { body, .. } => match body {
+                ArrowBody::Expr(e) => expr_uses_document(e),
+                ArrowBody::Block(s) => stmt_uses_document(s),
+            },
+            Expr::TemplateLiteral { exprs, .. } => exprs.iter().any(expr_uses_document),
+            Expr::Await { operand, .. } => expr_uses_document(operand),
+            Expr::JsxElement { props, children, .. } => {
+                props.iter().any(|p| match p {
+                    JsxProp::Attr { value, .. } => match value {
+                        JsxAttrValue::Expr(e) => expr_uses_document(e),
+                        JsxAttrValue::String(_) | JsxAttrValue::ImplicitTrue => false,
+                    },
+                    JsxProp::Spread(e) => expr_uses_document(e),
+                }) || children.iter().any(|c| match c {
+                    JsxChild::Expr(e) => expr_uses_document(e),
+                    JsxChild::Text(_) => false,
+                })
+            }
+            Expr::JsxFragment { children, .. } => children.iter().any(|c| match c {
+                JsxChild::Expr(e) => expr_uses_document(e),
+                JsxChild::Text(_) => false,
+            }),
+        }
+    }
+
+    fn stmt_uses_document(s: &Statement) -> bool {
+        match s {
+            Statement::VarDecl { init, .. } => init.as_ref().is_some_and(|e| expr_uses_document(e)),
+            Statement::VarDeclDestructure { init, .. } => expr_uses_document(init),
+            Statement::ExprStmt { expr, .. } => expr_uses_document(expr),
+            Statement::Return { value, .. } => value.as_ref().is_some_and(|e| expr_uses_document(e)),
+            Statement::Throw { value, .. } => expr_uses_document(value),
+            Statement::If {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
+                expr_uses_document(cond)
+                    || stmt_uses_document(then_branch)
+                    || else_branch
+                        .as_ref()
+                        .is_some_and(|b| stmt_uses_document(b.as_ref()))
+            }
+            Statement::While { cond, body, .. }
+            | Statement::DoWhile { cond, body, .. } => {
+                expr_uses_document(cond) || stmt_uses_document(body)
+            }
+            Statement::For { init, cond, update, body, .. } => {
+                init.as_ref().is_some_and(|s| stmt_uses_document(s.as_ref()))
+                    || cond.as_ref().is_some_and(|e| expr_uses_document(e))
+                    || update.as_ref().is_some_and(|e| expr_uses_document(e))
+                    || stmt_uses_document(body)
+            }
+            Statement::ForOf { iterable, body, .. } => {
+                expr_uses_document(iterable) || stmt_uses_document(body)
+            }
+            Statement::Switch {
+                expr,
+                cases,
+                default_body,
+                ..
+            } => {
+                expr_uses_document(expr)
+                    || cases.iter().any(|(e, stmts)| {
+                        e.as_ref().is_some_and(|e| expr_uses_document(e))
+                            || stmts.iter().any(stmt_uses_document)
+                    })
+                    || default_body
+                        .as_ref()
+                        .is_some_and(|stmts| stmts.iter().any(stmt_uses_document))
+            }
+            Statement::Block { statements, .. } => statements.iter().any(stmt_uses_document),
+            Statement::FunDecl { body, .. } => stmt_uses_document(body),
+            Statement::Try {
+                body,
+                catch_body,
+                finally_body,
+                ..
+            } => {
+                stmt_uses_document(body)
+                    || catch_body
+                        .as_ref()
+                        .is_some_and(|b| stmt_uses_document(b.as_ref()))
+                    || finally_body
+                        .as_ref()
+                        .is_some_and(|b| stmt_uses_document(b.as_ref()))
+            }
+            Statement::Import { .. }
+            | Statement::Export { .. }
+            | Statement::Break { .. }
+            | Statement::Continue { .. }
+            | Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. } => false,
+        }
+    }
+
+    program.statements.iter().any(stmt_uses_document)
+}
+
+/// When Tish uses bare `document`, link `tish-canvas` even without `import from 'tish:canvas'`.
+pub fn ensure_tish_canvas_module(
+    native_modules: &mut Vec<ResolvedNativeModule>,
+    project_root: &Path,
+) -> Result<(), String> {
+    if native_modules
+        .iter()
+        .any(|m| m.crate_name == "tish_canvas" || m.package_name == "tish-canvas")
+    {
+        return Ok(());
+    }
+    let m = resolve_native_module("tish:canvas", project_root)?;
+    native_modules.push(m);
+    Ok(())
+}
+
 /// True for `cargo:…` specs (Cargo-backed imports; Rust native backend only).
 pub fn is_cargo_native_spec(spec: &str) -> bool {
     spec.starts_with("cargo:")
@@ -723,11 +907,11 @@ fn load_module_recursive(
 /// - 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)
+///
+/// Scoped npm packages (`@scope/pkg`) are merged as Tish source unless imported via `tish:…`.
 pub fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
-        || spec.starts_with('@')
         || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
 }
 
@@ -774,7 +958,8 @@ fn resolve_package_root_to_entry(pkg_root: &Path, spec: &str) -> Option<PathBuf>
 pub fn resolve_bare_spec(spec: &str, from_dir: &Path, _project_root: &Path) -> Option<PathBuf> {
     let mut search = from_dir.to_path_buf();
     loop {
-        if let Some(p) = resolve_package_root_to_entry(&search.join("node_modules").join(spec), spec)
+        if let Some(p) =
+            resolve_package_root_to_entry(&search.join("node_modules").join(spec), spec)
         {
             return Some(p);
         }

package/crates/tish_compile/src/types.rs

@@ -83,9 +83,9 @@ impl RustType {
                     RustType::Value
                 }
             },
-            TypeAnnotation::Array(elem) => RustType::Vec(Box::new(
-                Self::from_annotation_with_aliases(elem, aliases),
-            )),
+            TypeAnnotation::Array(elem) => {
+                RustType::Vec(Box::new(Self::from_annotation_with_aliases(elem, aliases)))
+            }
             TypeAnnotation::Object(fields) => {
                 let typed_fields: Vec<_> = fields
                     .iter()
@@ -115,9 +115,9 @@ impl RustType {
                             |t| !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"),
                         );
                         if let Some(inner) = non_null {
-                            return RustType::Option(Box::new(
-                                Self::from_annotation_with_aliases(inner, aliases),
-                            ));
+                            return RustType::Option(Box::new(Self::from_annotation_with_aliases(
+                                inner, aliases,
+                            )));
                         }
                     }
                 }

package/crates/tish_compile_js/src/codegen.rs

@@ -72,7 +72,11 @@ impl Codegen {
     }
 
     fn output_line(&self) -> u32 {
-        self.output.as_bytes().iter().filter(|&&b| b == b'\n').count() as u32
+        self.output
+            .as_bytes()
+            .iter()
+            .filter(|&&b| b == b'\n')
+            .count() as u32
     }
 
     fn escape_ident(s: &str) -> String {
@@ -779,7 +783,8 @@ fn compile_project_js_inner(
     let modules = tishlang_compile::resolve_project(entry_path, project_root)
         .map_err(|e| CompileError { message: e })?;
     tishlang_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
-    let merged = tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
+    let merged =
+        tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
     let program = if optimize {
         tishlang_opt::optimize(&merged.program)
     } else {
@@ -862,7 +867,5 @@ pub fn compile_project_with_jsx(
     } else {
         format!("{stem}.js")
     };
-    Ok(
-        compile_project_js_inner(entry_path, project_root, optimize, false, &out_name)?.js,
-    )
+    Ok(compile_project_js_inner(entry_path, project_root, optimize, false, &out_name)?.js)
 }

package/crates/tish_core/src/console_style.rs

@@ -84,6 +84,7 @@ fn format_value_styled_inner(value: &Value, colors: bool, quote_strings: bool) -
         Value::Object(obj) => {
             let inner: Vec<String> = obj
                 .borrow()
+                .strings
                 .iter()
                 .map(|(k, v)| {
                     format!(
@@ -96,6 +97,14 @@ fn format_value_styled_inner(value: &Value, colors: bool, quote_strings: bool) -
             let sep = format!("{PUNCT}, {RESET}");
             format!("{PUNCT}{{{RESET} {} {PUNCT}}}{RESET}", inner.join(&sep))
         }
+        Value::Symbol(s) => {
+            let body = s
+                .description
+                .as_ref()
+                .map(|d| d.as_ref())
+                .unwrap_or("");
+            format!("{SPECIAL}Symbol({body}){RESET}")
+        }
         Value::Function(_) => format!("{SPECIAL}[Function]{RESET}"),
         Value::Promise(_) => format!("{SPECIAL}[object Promise]{RESET}"),
         Value::Opaque(o) => format!("{SPECIAL}[object {}]{RESET}", o.type_name()),

package/crates/tish_core/src/json.rs

@@ -70,8 +70,8 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
             let borrowed = obj.borrow();
             // Sort keys for deterministic output. Pre-allocate to avoid
             // a fresh `Vec` realloc inside `keys().collect()`.
-            let mut keys: Vec<&Arc<str>> = Vec::with_capacity(borrowed.len());
-            keys.extend(borrowed.keys());
+            let mut keys: Vec<&Arc<str>> = Vec::with_capacity(borrowed.strings.len());
+            keys.extend(borrowed.strings.keys());
             keys.sort_unstable_by(|a, b| a.as_ref().cmp(b.as_ref()));
             buf.push('{');
             for (i, key) in keys.into_iter().enumerate() {
@@ -81,11 +81,13 @@ pub fn json_stringify_into(buf: &mut String, value: &Value) {
                 buf.push('"');
                 escape_json_string_into(buf, key);
                 buf.push_str("\":");
-                json_stringify_into(buf, borrowed.get(key).unwrap());
+                json_stringify_into(buf, borrowed.strings.get(key).unwrap());
             }
             buf.push('}');
         }
-        Value::Function(_) | Value::Promise(_) | Value::Opaque(_) => buf.push_str("null"),
+        Value::Function(_) | Value::Promise(_) | Value::Opaque(_) | Value::Symbol(_) => {
+            buf.push_str("null");
+        }
         #[cfg(feature = "regex")]
         Value::RegExp(_) => buf.push_str("null"),
     }
@@ -312,7 +314,10 @@ fn parse_object(input: &str) -> Result<(Value, &str), String> {
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix('}') {
-        return Ok((Value::Object(VmRef::new(map)), rest));
+        return Ok((
+            Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+            rest,
+        ));
     }
 
     loop {
@@ -339,7 +344,12 @@ fn parse_object(input: &str) -> Result<(Value, &str), String> {
 
         match input.chars().next() {
             Some(',') => input = &input[1..],
-            Some('}') => return Ok((Value::Object(VmRef::new(map)), &input[1..])),
+            Some('}') => {
+                return Ok((
+                    Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+                    &input[1..],
+                ));
+            }
             _ => return Err("Expected ',' or '}' in object".to_string()),
         }
     }
@@ -369,7 +379,7 @@ mod tests {
 
         match (&value, &reparsed) {
             (Value::Object(a), Value::Object(b)) => {
-                assert_eq!(a.borrow().len(), b.borrow().len());
+                assert_eq!(a.borrow().len_entries(), b.borrow().len_entries());
             }
             _ => panic!("Expected objects"),
         }

package/crates/tish_core/src/macros.rs

@@ -24,13 +24,13 @@
 macro_rules! tish_module {
     ($($name:expr => $fn:expr),* $(,)?) => {{
         use std::sync::Arc;
-        use $crate::{ObjectMap, Value, VmRef};
+        use $crate::{ObjectMap, Value};
         let mut map = ObjectMap::default();
         $(
             // `Value::native` picks the right Rc / Arc wrapper depending on
             // whether the `send-values` feature is enabled upstream.
             map.insert(Arc::from($name), Value::native($fn));
         )*
-        Value::Object(VmRef::new(map))
+        Value::object(map)
     }};
 }