@tishlang/tish 1.0.29 → 1.0.34

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -211,4 +211,72 @@ fn FileList() {
             &js[..900.min(js.len())]
         );
     }
+
+    #[test]
+    fn new_date_global_emits_valid_js_with_and_without_optimize() {
+        let src = "let epoch = new Date(0)\nconsole.log(epoch.getTime())";
+        let program = parse(src).expect("parse");
+        for optimize in [false, true] {
+            let js = compile_with_jsx(&program, optimize).expect("compile");
+            assert!(
+                js.contains("new Date(0)"),
+                "optimize={optimize}: expected `new Date(0)` in JS output:\n{js}"
+            );
+            assert!(
+                !js.contains("let epoch = new;"),
+                "optimize={optimize}: broken `new` emission (missing constructor):\n{js}"
+            );
+        }
+    }
+
+    #[test]
+    fn new_uint8array_emits_direct_new_no_preamble() {
+        let src = "fn f(n) { return new Uint8Array(n) }";
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new Uint8Array("),
+            "expected direct new Uint8Array, got: {}",
+            &js[..500.min(js.len())]
+        );
+        assert!(
+            !js.contains("__tishUint8Array"),
+            "should not emit legacy intrinsic helper"
+        );
+    }
+
+    #[test]
+    fn new_audio_context_emits_direct_new_no_preamble() {
+        let src = "fn f() { return new AudioContext() }";
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new AudioContext("),
+            "expected new AudioContext, got: {}",
+            &js[..500.min(js.len())]
+        );
+        assert!(
+            !js.contains("__tishWebAudioCreateContext"),
+            "should not emit legacy intrinsic helper"
+        );
+    }
+
+    #[test]
+    fn new_class_name_emits_direct_new_js() {
+        let src = r#"
+fn ClassName(x) {
+    return x
+}
+fn factory() {
+    return new ClassName(42)
+}
+"#;
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new ClassName("),
+            "expected new ClassName( in JS output, got: {}",
+            &js[..800.min(js.len())]
+        );
+    }
 }

package/crates/tish_core/Cargo.toml

@@ -11,4 +11,8 @@ default = []
 regex = ["dep:fancy-regex"]
 
 [dependencies]
+ahash = "0.8.11"
 fancy-regex = { version = "0.17.0", optional = true }
+
+[target.wasm32-unknown-unknown.dependencies]
+getrandom = { version = "0.3", features = ["wasm_js"] }

package/crates/tish_core/src/console_style.rs

@@ -4,9 +4,12 @@
 //! booleans, null, and object structure are easier to scan.
 
 use std::io::IsTerminal;
+use std::sync::OnceLock;
 
 use crate::Value;
 
+static CONSOLE_USES_COLORS: OnceLock<bool> = OnceLock::new();
+
 /// ANSI escape codes (standard 4-bit + bright black for dim).
 const RESET: &str = "\x1b[0m";
 /// Number: yellow (Node-style)
@@ -25,8 +28,11 @@ const PUNCT: &str = "\x1b[90m";
 const SPECIAL: &str = "\x1b[90m";
 
 /// Returns whether console output should use colors (stdout is a TTY).
+///
+/// Cached for the process lifetime. `is_terminal()` is a syscall; benchmarks and
+/// scripts with many `console.log` calls must not pay it on every line.
 pub fn use_console_colors() -> bool {
-    std::io::stdout().is_terminal()
+    *CONSOLE_USES_COLORS.get_or_init(|| std::io::stdout().is_terminal())
 }
 
 /// Format a single value for console with optional ANSI colors (Node/Bun-style).

package/crates/tish_core/src/json.rs

@@ -2,7 +2,6 @@
 
 use crate::Value;
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
@@ -260,7 +259,7 @@ fn parse_array(input: &str) -> Result<(Value, &str), String> {
 
 fn parse_object(input: &str) -> Result<(Value, &str), String> {
     let mut input = &input[1..]; // skip '{'
-    let mut map = HashMap::new();
+    let mut map = crate::ObjectMap::default();
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix('}') {

package/crates/tish_core/src/macros.rs

@@ -24,11 +24,10 @@
 macro_rules! tish_module {
     ($($name:expr => $fn:expr),* $(,)?) => {{
         use std::cell::RefCell;
-        use std::collections::HashMap;
         use std::rc::Rc;
         use std::sync::Arc;
-        use $crate::Value;
-        let mut map = HashMap::new();
+        use $crate::{ObjectMap, Value};
+        let mut map = ObjectMap::default();
         $(
             map.insert(Arc::from($name), Value::Function(Rc::new($fn)));
         )*

package/crates/tish_core/src/value.rs

@@ -1,10 +1,15 @@
 //! Unified Value type for Tish runtime values.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
+use ahash::AHashMap;
+
+/// Property map for objects and other `Arc<str>` → `Value` tables (VM globals, scopes).
+/// Uses a faster hasher than `std::collections::HashMap` for string-heavy workloads.
+pub type ObjectMap = AHashMap<Arc<str>, Value>;
+
 #[cfg(feature = "regex")]
 use fancy_regex::Regex;
 
@@ -20,6 +25,9 @@ pub trait TishOpaque: Send + Sync {
 
     /// Get a method by name. Returns a native function if the method exists.
     fn get_method(&self, name: &str) -> Option<NativeFn>;
+
+    /// For downcasting `Arc<dyn TishOpaque>` in native crates (e.g. Polars → `DataFrame`).
+    fn as_any(&self) -> &dyn std::any::Any;
 }
 
 /// Trait for Promise-like values that can be awaited (block until settled).
@@ -147,7 +155,7 @@ pub enum Value {
     Bool(bool),
     Null,
     Array(Rc<RefCell<Vec<Value>>>),
-    Object(Rc<RefCell<HashMap<Arc<str>, Value>>>),
+    Object(Rc<RefCell<ObjectMap>>),
     Function(NativeFn),
     #[cfg(feature = "regex")]
     RegExp(Rc<RefCell<TishRegExp>>),
@@ -256,8 +264,8 @@ impl Value {
         Value::Array(Rc::new(RefCell::new(items)))
     }
 
-    /// Create a new object Value from a HashMap.
-    pub fn object(map: HashMap<Arc<str>, Value>) -> Self {
+    /// Create a new object Value from a property map.
+    pub fn object(map: ObjectMap) -> Self {
         Value::Object(Rc::new(RefCell::new(map)))
     }
 
@@ -268,7 +276,7 @@ impl Value {
 
     /// Create an empty object Value.
     pub fn empty_object() -> Self {
-        Value::Object(Rc::new(RefCell::new(HashMap::new())))
+        Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
     }
 
     /// Extract the number value, if this is a Number.

package/crates/tish_cranelift/src/lib.rs

@@ -1,6 +1,8 @@
-//! Bytecode to native via Cranelift.
+//! Standalone native binary: embedded bytecode + VM (Cranelift used as object builder).
 //!
-//! Compiles Tish bytecode to native object files and links with a minimal runtime.
+//! Produces an executable that runs **`tishlang_vm`** on serialized bytecode embedded in
+//! the binary — not lowering of Tish opcodes to CLIF/machine code (see module docs in
+//! `lower.rs`). For Rust transpile + `tishlang_runtime`, use `--native-backend rust`.
 
 mod link;
 mod lower;
@@ -25,8 +27,8 @@ impl std::fmt::Display for CraneliftError {
 
 impl std::error::Error for CraneliftError {}
 
-/// Compile a bytecode chunk to a native binary.
-/// `features` are passed to tishlang_cranelift_runtime (e.g. fs, process, http for built-in modules).
+/// Build a native binary that embeds `chunk` and runs it with the bytecode VM.
+/// `features` are passed to `tishlang_cranelift_runtime` (e.g. fs, process, http).
 pub fn compile_chunk_to_native(
     chunk: &Chunk,
     output_path: &Path,

package/crates/tish_cranelift/src/lower.rs

@@ -1,7 +1,9 @@
-//! Bytecode to Cranelift IR lowering.
+//! Embed serialized bytecode in an object file for the standalone native binary.
 //!
-//! Emits object file with tish_chunk_data and tish_chunk_len symbols.
-//! The link step builds a Rust binary that reads these and runs via tishlang_vm.
+//! **This is not AOT compilation of Tish into Cranelift IR.** The chunk is stored as
+//! read-only data (`tish_chunk_data`, `tish_chunk_len`). The link step produces an
+//! executable that **deserializes the chunk and runs `tishlang_vm`** — same VM as
+//! `tish run --backend vm`. Cranelift is only the object-file emitter for that blob.
 
 use std::path::Path;
 

package/crates/tish_cranelift_runtime/src/lib.rs

@@ -1,6 +1,8 @@
-//! Runtime for Cranelift-compiled Tish programs.
+//! Runtime linked into the `tish compile --native-backend cranelift` executable.
 //!
-//! Provides tish_run_chunk(ptr, len) which deserializes and runs bytecode.
+//! **`tish_run_chunk`** deserializes embedded bytecode and runs **`tishlang_vm`** — the same
+//! execution engine as `tish run --backend vm`. The crate name is historical; this is not
+//! running CLIF-emitted machine code for each Tish opcode.
 
 use tishlang_bytecode::deserialize;
 use tishlang_vm::Vm;

package/crates/tish_eval/Cargo.toml

@@ -16,8 +16,10 @@ tokio = ["dep:tokio"]
 ws = ["dep:tishlang_runtime", "tishlang_runtime/ws"]
 
 [dependencies]
+ahash = "0.8.12"
 rand = "0.10.0"
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_builtins = { path = "../tish_builtins", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 reqwest = { version = "0.13.2", default-features = false, features = ["rustls", "json", "stream"], optional = true }