@tishlang/tish 1.0.29 → 1.0.33

package/crates/tish_compile/src/lib.rs

@@ -53,6 +53,41 @@ for (let i = 0; i < 5; i = i + 1) {
         );
     }
 
+    #[test]
+    fn new_expression_lowers_to_construct_on_native() {
+        let src = "fn f() { return new Uint8Array(4) }";
+        let program = parse(src).unwrap();
+        let rust = compile(&program).unwrap();
+        assert!(
+            rust.contains("tish_construct"),
+            "expected new to lower to tish_construct, got snippet missing it"
+        );
+    }
+
+    /// User-defined constructor name: `new ClassName(...)` must compile natively (host `construct`)
+    /// and is the same surface syntax as the JS target (`new` in emitted JavaScript).
+    #[test]
+    fn new_class_name_compiles_native_via_tish_construct() {
+        let src = r#"
+fn ClassName(x) {
+    return x
+}
+fn factory() {
+    return new ClassName(42)
+}
+"#;
+        let program = parse(src).unwrap();
+        let rust = compile(&program).unwrap();
+        assert!(
+            rust.contains("tish_construct"),
+            "expected new ClassName to lower to tish_construct"
+        );
+        assert!(
+            rust.contains("ClassName"),
+            "expected emitted Rust to reference ClassName callable"
+        );
+    }
+
     #[test]
     fn loop_var_decl_clone_via_project_full() {
         let manifest = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));

package/crates/tish_compile_js/Cargo.toml

@@ -14,3 +14,4 @@ tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
+tishlang_ui = { path = "../tish_ui", default-features = false, features = ["compiler"] }

package/crates/tish_compile_js/src/codegen.rs

@@ -2,18 +2,15 @@
 
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr,
-    JsxAttrValue, JsxChild, JsxProp, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program,
-    Statement, UnaryOp,
+    FunParam, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, UnaryOp,
 };
 
 use crate::error::CompileError;
-use crate::js_intrinsics::{JsIntrinsic, JsIntrinsics};
 
 struct Codegen {
     output: String,
     indent: usize,
     in_async: bool,
-    intrinsics: JsIntrinsics,
 }
 
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
@@ -29,7 +26,6 @@ impl Codegen {
             output: String::new(),
             indent: 0,
             in_async: false,
-            intrinsics: JsIntrinsics::new(),
         }
     }
 
@@ -61,9 +57,6 @@ impl Codegen {
         for stmt in &program.statements {
             self.emit_statement(stmt)?;
         }
-        self.output = self
-            .intrinsics
-            .prepend_runtime_preamble(std::mem::take(&mut self.output));
         Ok(())
     }
 
@@ -304,20 +297,34 @@ impl Codegen {
 
     fn emit_params(
         &mut self,
-        params: &[tishlang_ast::TypedParam],
+        params: &[FunParam],
         rest_param: Option<&tishlang_ast::TypedParam>,
     ) -> Result<String, CompileError> {
-        let mut parts: Vec<String> = params
-            .iter()
-            .map(|p| {
-                let n = Self::escape_ident(p.name.as_ref());
-                if let Some(ref d) = p.default {
-                    format!("{} = {}", n, self.emit_expr(d).unwrap())
-                } else {
-                    n
+        let mut parts: Vec<String> = Vec::new();
+        for p in params {
+            match p {
+                FunParam::Simple(tp) => {
+                    let n = Self::escape_ident(tp.name.as_ref());
+                    let s = if let Some(ref d) = tp.default {
+                        format!("{} = {}", n, self.emit_expr(d)?)
+                    } else {
+                        n
+                    };
+                    parts.push(s);
+                }
+                FunParam::Destructure {
+                    pattern,
+                    type_ann: _,
+                    default,
+                } => {
+                    let mut s = self.emit_destruct_pattern(pattern)?;
+                    if let Some(ref d) = default {
+                        s = format!("{} = {}", s, self.emit_expr(d)?);
+                    }
+                    parts.push(s);
                 }
-            })
-            .collect();
+            }
+        }
         if let Some(rest) = rest_param {
             parts.push(format!("...{}", Self::escape_ident(rest.name.as_ref())));
         }
@@ -421,16 +428,6 @@ impl Codegen {
                 }
             }
             Expr::Call { callee, args, .. } => {
-                if let Some(kind) =
-                    JsIntrinsics::classify_call(callee.as_ref(), args)?
-                {
-                    self.intrinsics.mark(kind);
-                    if kind == JsIntrinsic::Uint8Array {
-                        let n = self.emit_call_arg(&args[0])?;
-                        return Ok(JsIntrinsics::emit_expr(kind, &n));
-                    }
-                    return Ok(JsIntrinsics::emit_expr(kind, ""));
-                }
                 let c = self.emit_expr(callee)?;
                 let arg_strs: Result<Vec<_>, _> =
                     args.iter().map(|a| self.emit_call_arg(a)).collect();
@@ -438,6 +435,13 @@ impl Codegen {
                 // Tish uses null for undefined (e.g. empty array pop/shift)
                 format!("({}({}) ?? null)", c, arg_strs)
             }
+            Expr::New { callee, args, .. } => {
+                let c = self.emit_expr(callee)?;
+                let arg_strs: Result<Vec<_>, _> =
+                    args.iter().map(|a| self.emit_call_arg(a)).collect();
+                let arg_strs = arg_strs?.join(", ");
+                format!("(new {}({}) ?? null)", c, arg_strs)
+            }
             Expr::Member {
                 object,
                 prop,
@@ -625,23 +629,11 @@ impl Codegen {
                 let o = self.emit_expr(operand)?;
                 format!("(await {})", o)
             }
-            Expr::JsxElement { tag, props, children, .. } => {
-                let tag_str = if tag.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) {
-                    tag.as_ref().to_string()
-                } else {
-                    format!("{:?}", tag.as_ref())
-                };
-                let props_str = self.emit_jsx_props(props)?;
-                let children_strs: Result<Vec<_>, _> =
-                    children.iter().map(|c| self.emit_jsx_child(c)).collect();
-                let children_str = children_strs?.join(", ");
-                format!("h({}, {}, [{}])", tag_str, props_str, children_str)
-            }
-            Expr::JsxFragment { children, .. } => {
-                let children_strs: Result<Vec<_>, _> =
-                    children.iter().map(|c| self.emit_jsx_child(c)).collect();
-                let children_str = children_strs?.join(", ");
-                format!("h(Fragment, null, [{}])", children_str)
+            Expr::JsxElement { .. } | Expr::JsxFragment { .. } => {
+                tishlang_ui::jsx::emit_jsx_js(expr, &mut |e| {
+                    self.emit_expr(e).map_err(|ce| ce.message)
+                })
+                .map_err(|m| CompileError { message: m })?
             }
             Expr::NativeModuleLoad { spec, .. } => {
                 return Err(CompileError {
@@ -661,54 +653,6 @@ impl Codegen {
         }
     }
 
-    fn emit_jsx_props(&mut self, props: &[JsxProp]) -> Result<String, CompileError> {
-        if props.is_empty() {
-            return Ok("null".to_string());
-        }
-        let parts: Result<Vec<_>, _> = props
-            .iter()
-            .map(|p| match p {
-                JsxProp::Attr { name, value } => {
-                    let val = match value {
-                        JsxAttrValue::String(s) => format!("{:?}", s.as_ref()),
-                        JsxAttrValue::Expr(e) => self.emit_expr(e)?,
-                        JsxAttrValue::ImplicitTrue => "true".to_string(),
-                    };
-                    let key = name.as_ref();
-                    Ok(if key.chars().all(|c| c.is_alphanumeric() || c == '_') {
-                        format!("{}: {}", key, val)
-                    } else {
-                        format!("{:?}: {}", key, val)
-                    })
-                }
-                JsxProp::Spread(e) => Ok(format!("...{}", self.emit_expr(e)?)),
-            })
-            .collect();
-        Ok(format!("{{ {} }}", parts?.join(", ")))
-    }
-
-    fn emit_jsx_child(&mut self, child: &JsxChild) -> Result<String, CompileError> {
-        match child {
-            JsxChild::Text(s) => Ok(format!("{:?}", s.as_ref())),
-            JsxChild::Expr(e) => {
-                let inner = self.emit_expr(e)?;
-                // Only wrap literals we know are primitives (number, bool, null). Never wrap:
-                // string/template (already strings), JSX (elements), Call (components), Array/Ident (may hold elements).
-                let needs_string = matches!(
-                    e,
-                    Expr::Literal {
-                        value: Literal::Number(_) | Literal::Bool(_) | Literal::Null,
-                        ..
-                    }
-                );
-                Ok(if needs_string {
-                    format!("String({})", inner)
-                } else {
-                    inner
-                })
-            }
-        }
-    }
 }
 
 /// Compile a single program (no imports) to JavaScript. JSX lowers to `h` / `Fragment` (Lattish).

package/crates/tish_compile_js/src/lib.rs

@@ -3,7 +3,6 @@
 
 mod codegen;
 mod error;
-mod js_intrinsics;
 
 #[cfg(test)]
 mod tests_jsx;

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;
 
@@ -147,7 +152,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 +261,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 +273,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_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 }