@tishlang/tish 1.0.29 → 1.0.34

package/crates/tish_eval/src/regex.rs

@@ -3,12 +3,13 @@
 //! Re-exports core types from tishlang_core and provides interpreter-specific functionality.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
 pub use tishlang_core::{RegExpFlags, TishRegExp};
 
+use crate::value::PropMap;
+
 use crate::value::Value;
 
 /// RegExp.prototype.exec(string) - returns match object (array-like with index) or null
@@ -42,7 +43,7 @@ pub fn regexp_exec(re: &mut TishRegExp, input: &str) -> Value {
             let match_byte_start = byte_start + full_match.start();
             let match_char_index = input[..match_byte_start].chars().count();
 
-            let mut obj: HashMap<Arc<str>, Value> = HashMap::new();
+            let mut obj: PropMap = PropMap::default();
             obj.insert(Arc::from("0"), Value::String(full_match.as_str().into()));
             for i in 1..caps.len() {
                 let val = match caps.get(i) {

package/crates/tish_eval/src/value.rs

@@ -6,13 +6,15 @@
 //! different shape (no AST-carrying variants). The split is intentional.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use tishlang_ast::{Expr, Statement};
-#[cfg(any(feature = "http", feature = "ws"))]
+use ahash::AHashMap;
+use tishlang_ast::{FunParam, Statement};
 use tishlang_core::NativeFn as CoreNativeFn;
+
+/// Property map for interpreter `Value::Object` (uses `eval::Value`, not `tishlang_core::Value`).
+pub type PropMap = AHashMap<Arc<str>, Value>;
 #[cfg(feature = "http")]
 use tishlang_core::TishPromise;
 use tishlang_core::TishOpaque;
@@ -32,11 +34,10 @@ pub enum Value {
     Bool(bool),
     Null,
     Array(Rc<RefCell<Vec<Value>>>),
-    Object(Rc<RefCell<HashMap<Arc<str>, Value>>>),
+    Object(Rc<RefCell<PropMap>>),
     /// User-defined function with AST body
     Function {
-        params: Arc<[Arc<str>]>,
-        defaults: Arc<[Option<Expr>]>,
+        formals: Arc<[FunParam]>,
         rest_param: Option<Arc<str>>,
         body: Arc<Statement>,
     },
@@ -65,8 +66,7 @@ pub enum Value {
     /// Native `tishlang_core` Promise (fetch / reader.read / response.text).
     #[cfg(feature = "http")]
     CorePromise(Arc<dyn TishPromise>),
-    /// `tishlang_core::Value::Function` (e.g. response.text/json, ws send/receive) callable from eval.
-    #[cfg(any(feature = "http", feature = "ws"))]
+    /// `tishlang_core::Value::Function` (native callbacks, `new` constructors, fetch/ws when enabled).
     CoreFn(CoreNativeFn),
     /// Opaque handle to a native Rust type (e.g. Polars DataFrame).
     Opaque(Arc<dyn TishOpaque>),
@@ -99,7 +99,6 @@ impl std::fmt::Debug for Value {
             Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => write!(f, "[Function]"),
             #[cfg(feature = "http")]
             Value::CorePromise(_) => write!(f, "Promise"),
-            #[cfg(any(feature = "http", feature = "ws"))]
             Value::CoreFn(_) => write!(f, "CoreFn"),
             Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
             Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
@@ -155,7 +154,6 @@ impl std::fmt::Display for Value {
             Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => write!(f, "[Function]"),
             #[cfg(feature = "http")]
             Value::CorePromise(_) => write!(f, "[Promise]"),
-            #[cfg(any(feature = "http", feature = "ws"))]
             Value::CoreFn(_) => write!(f, "[Function]"),
             Value::Opaque(o) => write!(f, "[object {}]", o.type_name()),
             Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
@@ -199,8 +197,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: PropMap) -> Self {
         Value::Object(Rc::new(RefCell::new(map)))
     }
 
@@ -211,7 +209,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(PropMap::default())))
     }
 
     /// Extract the number value, if this is a Number.

package/crates/tish_eval/src/value_convert.rs

@@ -1,13 +1,12 @@
 //! Conversion between tishlang_eval::Value and tishlang_core::Value for opaque method calls.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use tishlang_core::Value as CoreValue;
+use tishlang_core::{ObjectMap, Value as CoreValue};
 
-use crate::value::Value;
+use crate::value::{PropMap, Value};
 
 /// Convert interpreter Value to core Value. Fails for interpreter-only variants.
 pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
@@ -24,7 +23,7 @@ pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
             Ok(CoreValue::Array(Rc::new(RefCell::new(out))))
         }
         Value::Object(map) => {
-            let mut out = HashMap::new();
+            let mut out = ObjectMap::default();
             for (k, v) in map.borrow().iter() {
                 out.insert(Arc::clone(k), eval_to_core(v)?);
             }
@@ -53,7 +52,7 @@ pub fn core_to_eval(v: CoreValue) -> Value {
             Value::Array(Rc::new(RefCell::new(out)))
         }
         CoreValue::Object(map) => {
-            let mut out = HashMap::new();
+            let mut out = PropMap::default();
             for (k, v) in map.borrow().iter() {
                 out.insert(Arc::clone(k), core_to_eval(v.clone()));
             }
@@ -64,10 +63,7 @@ pub fn core_to_eval(v: CoreValue) -> Value {
         CoreValue::Promise(p) => Value::CorePromise(Arc::clone(&p)),
         #[cfg(not(feature = "http"))]
         CoreValue::Promise(_) => Value::Null,
-        #[cfg(any(feature = "http", feature = "ws"))]
         CoreValue::Function(f) => Value::CoreFn(Rc::clone(&f)),
-        #[cfg(not(any(feature = "http", feature = "ws")))]
-        CoreValue::Function(_) => Value::Null,
         // tishlang_core gets regex from http or regex features; handle RegExp when it exists
         #[cfg(any(feature = "http", feature = "regex"))]
         CoreValue::RegExp(re) => {

package/crates/tish_fmt/src/lib.rs

@@ -2,7 +2,7 @@
 
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
-    ExportDeclaration, Expr, ImportSpecifier, JsxAttrValue, JsxChild, JsxProp,
+    ExportDeclaration, Expr, FunParam, ImportSpecifier, JsxAttrValue, JsxChild, JsxProp,
     Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, TypeAnnotation,
     TypedParam, UnaryOp,
 };
@@ -385,19 +385,38 @@ impl Printer {
         self.buf.push_str(" }");
     }
 
-    fn param_list(&mut self, params: &[TypedParam], rest: &Option<TypedParam>) {
+    fn param_list(&mut self, params: &[FunParam], rest: &Option<TypedParam>) {
         for (i, p) in params.iter().enumerate() {
             if i > 0 {
                 self.buf.push_str(", ");
             }
-            self.buf.push_str(p.name.as_ref());
-            if let Some(t) = &p.type_ann {
-                self.buf.push_str(": ");
-                self.type_ann(t);
-            }
-            if let Some(e) = &p.default {
-                self.buf.push_str(" = ");
-                self.expr(e);
+            match p {
+                FunParam::Simple(tp) => {
+                    self.buf.push_str(tp.name.as_ref());
+                    if let Some(t) = &tp.type_ann {
+                        self.buf.push_str(": ");
+                        self.type_ann(t);
+                    }
+                    if let Some(e) = &tp.default {
+                        self.buf.push_str(" = ");
+                        self.expr(e);
+                    }
+                }
+                FunParam::Destructure {
+                    pattern,
+                    type_ann,
+                    default,
+                } => {
+                    self.destruct_pat(pattern);
+                    if let Some(t) = type_ann {
+                        self.buf.push_str(": ");
+                        self.type_ann(t);
+                    }
+                    if let Some(e) = default {
+                        self.buf.push_str(" = ");
+                        self.expr(e);
+                    }
+                }
             }
         }
         if let Some(r) = rest {
@@ -551,6 +570,26 @@ impl Printer {
                 }
                 self.buf.push(')');
             }
+            Expr::New { callee, args, .. } => {
+                self.buf.push_str("new ");
+                self.expr(callee);
+                if !args.is_empty() {
+                    self.buf.push('(');
+                    for (i, a) in args.iter().enumerate() {
+                        if i > 0 {
+                            self.buf.push_str(", ");
+                        }
+                        match a {
+                            CallArg::Expr(ex) => self.expr(ex),
+                            CallArg::Spread(ex) => {
+                                self.buf.push_str("...");
+                                self.expr(ex);
+                            }
+                        }
+                    }
+                    self.buf.push(')');
+                }
+            }
             Expr::Member {
                 object,
                 prop,

package/crates/tish_lexer/src/token.rs

@@ -54,6 +54,7 @@ pub enum TokenKind {
     In,
     Async,
     Await,
+    New,
     Import,
     Export,
 
@@ -149,6 +150,7 @@ impl TokenKind {
             "in" => TokenKind::In,
             "async" => TokenKind::Async,
             "await" => TokenKind::Await,
+            "new" => TokenKind::New,
             "import" => TokenKind::Import,
             "export" => TokenKind::Export,
             _ => TokenKind::Ident,

package/crates/tish_lint/src/lib.rs

@@ -180,6 +180,15 @@ fn lint_expr(e: &Expr, out: &mut Vec<LintDiagnostic>) {
                 }
             }
         }
+        Expr::New { callee, args, .. } => {
+            lint_expr(callee, out);
+            for a in args {
+                match a {
+                    tishlang_ast::CallArg::Expr(x) => lint_expr(x, out),
+                    tishlang_ast::CallArg::Spread(x) => lint_expr(x, out),
+                }
+            }
+        }
         Expr::Member { object, .. } => {
             lint_expr(object, out);
         }

package/crates/tish_llvm/src/lib.rs

@@ -1,8 +1,8 @@
-//! LLVM backend for Tish.
+//! LLVM/clang link path for the **embedded-bytecode + VM** native binary.
 //!
-//! Compiles Tish bytecode to native binary using clang (LLVM toolchain).
-//! Emits a C file with embedded bytecode, compiles with clang to object code,
-//! then links with tishlang_cranelift_runtime.
+//! Emits a C file that only holds the serialized chunk as bytes; clang produces `chunk.o`,
+//! then links with **`tishlang_cranelift_runtime`** (same `tish_run_chunk` + `tishlang_vm`
+//! entry as `--native-backend cranelift`). This is **not** LLVM IR lowering of Tish opcodes.
 
 use std::fs;
 use std::path::Path;

package/crates/tish_lsp/README.md

@@ -5,7 +5,7 @@ Language Server Protocol implementation for [Tish](https://github.com/tishlang/t
 ## Build
 
 ```bash
-cargo build --release -p tish_lsp
+cargo build --release -p tishlang_lsp
 ```
 
 Binary: `target/release/tish-lsp` (stdio LSP).

package/crates/tish_native/src/build.rs

@@ -45,6 +45,19 @@ pub fn build_via_cargo(
         })
         .collect();
 
+    let tish_ui_path = std::path::Path::new(&runtime_path)
+        .parent()
+        .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
+        .join("tish_ui");
+    let ui_dep = if rust_code.contains("tishlang_ui") {
+        format!(
+            "\ntishlang_ui = {{ path = {:?}, default-features = false, features = [\"runtime\"] }}\n",
+            tish_ui_path.display().to_string().replace('\\', "/")
+        )
+    } else {
+        String::new()
+    };
+
     let cargo_toml = format!(
         r#"[package]
 name = "tish_output"
@@ -63,7 +76,7 @@ codegen-units = 1
 lto = "thin"
 
 [dependencies]
-tishlang_runtime = {{ path = {:?}{} }}{}{}
+tishlang_runtime = {{ path = {:?}{} }}{}{}{}
 "#,
         out_name,
         runtime_path,
@@ -73,7 +86,8 @@ tishlang_runtime = {{ path = {:?}{} }}{}{}
             String::new()
         } else {
             format!("\n{}", native_deps)
-        }
+        },
+        ui_dep
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)

package/crates/tish_native/src/lib.rs

@@ -1,14 +1,13 @@
 //! Native code generation backend for Tish.
 //!
-//! Target architecture (per plan):
-//! - Phase 2: Bytecode -> Cranelift IR -> .o -> link with minimal runtime
-//! - Current: Delegates to tishlang_compile (Rust codegen) + cargo build as interim path
+//! - **`rust`:** `tishlang_compile` emits Rust calling **`tishlang_runtime`** (`Value`, etc.),
+//!   then `cargo build --release` links the user binary.
+//! - **`cranelift`:** Embeds serialized bytecode in an object file and links **`tishlang_cranelift_runtime`**
+//!   — the executable runs **`tishlang_vm`** on that chunk (same as `tish run --backend vm`), not CLIF lowering.
+//! - **`llvm`:** Same embedded-bytecode + VM link path via `tishlang_llvm` / shared linker.
 //!
-//! Once Cranelift backend is implemented, this crate will:
-//! 1. Take Chunk (bytecode) as input
-//! 2. Lower to Cranelift IR
-//! 3. Emit .o via cranelift-object
-//! 4. Link against prebuilt tishlang_runtime staticlib
+//! **Future:** Lower bytecode (or typed IR) through Cranelift/LLVM to real machine code where semantics allow;
+//! emit Rust using `Vec<f64>` / fixed primitives instead of `Value` on hot paths.
 
 mod build;
 
@@ -31,9 +30,9 @@ impl std::error::Error for NativeError {}
 
 /// Compile a Tish project to a native binary.
 ///
-/// - `native_backend == "rust"`: Full Rust codegen + cargo build (supports native imports).
-/// - `native_backend == "cranelift"`: Bytecode -> Cranelift -> native (pure Tish only).
-/// - `native_backend == "llvm"`: Experimental LLVM backend (not implemented yet).
+/// - `native_backend == "rust"`: Rust source + `tishlang_runtime` + cargo (native imports).
+/// - `native_backend == "cranelift"`: Embedded bytecode + VM binary (pure Tish only); not opcode AOT yet.
+/// - `native_backend == "llvm"`: Embedded bytecode + VM via LLVM/clang link path.
 pub fn compile_to_native(
     entry_path: &Path,
     project_root: Option<&Path>,

package/crates/tish_opt/src/lib.rs

@@ -339,6 +339,21 @@ fn optimize_expr(expr: &Expr) -> Expr {
                 .collect(),
             span: *span,
         },
+        Expr::New {
+            callee,
+            args,
+            span,
+        } => Expr::New {
+            callee: Box::new(optimize_expr(callee)),
+            args: args
+                .iter()
+                .map(|a| match a {
+                    tishlang_ast::CallArg::Expr(e) => tishlang_ast::CallArg::Expr(optimize_expr(e)),
+                    tishlang_ast::CallArg::Spread(e) => tishlang_ast::CallArg::Spread(optimize_expr(e)),
+                })
+                .collect(),
+            span: *span,
+        },
         Expr::Member {
             object,
             prop,

package/crates/tish_parser/src/lib.rs

@@ -18,7 +18,7 @@ pub fn parse(source: &str) -> Result<Program, String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tishlang_ast::{Expr, ObjectProp, Statement};
+    use tishlang_ast::{CallArg, Expr, ObjectProp, Statement};
 
     #[test]
     fn test_async_fn_parse() {
@@ -120,4 +120,104 @@ mod tests {
             _ => panic!("expected KeyValue prop"),
         }
     }
+
+    fn unwrap_expr_stmt(program: &tishlang_ast::Program) -> &Expr {
+        match program.statements.first() {
+            Some(Statement::ExprStmt { expr, .. }) => expr,
+            _ => panic!("expected expression statement"),
+        }
+    }
+
+    #[test]
+    fn new_expression_simple_call() {
+        let program = parse("new Foo()").expect("parse");
+        let e = unwrap_expr_stmt(&program);
+        match e {
+            Expr::New { callee, args, .. } => {
+                assert!(matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Foo"));
+                assert!(args.is_empty());
+            }
+            _ => panic!("expected New, got {:?}", e),
+        }
+    }
+
+    #[test]
+    fn new_expression_with_args() {
+        let program = parse("new Uint8Array(16)").expect("parse");
+        let e = unwrap_expr_stmt(&program);
+        match e {
+            Expr::New { callee, args, .. } => {
+                assert!(matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Uint8Array"));
+                assert_eq!(args.len(), 1);
+                assert!(matches!(&args[0], CallArg::Expr(Expr::Literal { .. })));
+            }
+            _ => panic!("expected New"),
+        }
+    }
+
+    #[test]
+    fn new_expression_member_callee() {
+        let program = parse("new ns.AudioContext()").expect("parse");
+        let e = unwrap_expr_stmt(&program);
+        match e {
+            Expr::New { callee, args, .. } => {
+                assert!(matches!(
+                    callee.as_ref(),
+                    Expr::Member { prop: tishlang_ast::MemberProp::Name(p), .. } if p.as_ref() == "AudioContext"
+                ));
+                assert!(args.is_empty());
+            }
+            _ => panic!("expected New"),
+        }
+    }
+
+    #[test]
+    fn new_expression_chained_new() {
+        let program = parse("new new Date()").expect("parse");
+        let e = unwrap_expr_stmt(&program);
+        match e {
+            Expr::New { callee, args, .. } => {
+                assert!(args.is_empty());
+                match callee.as_ref() {
+                    Expr::New { callee: inner, args: inner_args, .. } => {
+                        assert!(matches!(inner.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Date"));
+                        assert!(inner_args.is_empty());
+                    }
+                    _ => panic!("expected nested New"),
+                }
+            }
+            _ => panic!("expected New"),
+        }
+    }
+
+    #[test]
+    fn new_then_member_access() {
+        let program = parse("new Foo().bar").expect("parse");
+        let e = unwrap_expr_stmt(&program);
+        match e {
+            Expr::Member { object, prop: tishlang_ast::MemberProp::Name(p), .. } => {
+                assert_eq!(p.as_ref(), "bar");
+                match object.as_ref() {
+                    Expr::New { callee, args, .. } => {
+                        assert!(matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Foo"));
+                        assert!(args.is_empty());
+                    }
+                    _ => panic!("expected New object"),
+                }
+            }
+            _ => panic!("expected Member"),
+        }
+    }
+
+    #[test]
+    fn new_with_spread_arg() {
+        let program = parse("new Foo(...xs)").expect("parse");
+        let e = unwrap_expr_stmt(&program);
+        match e {
+            Expr::New { args, .. } => {
+                assert!(matches!(&args[0], CallArg::Spread(Expr::Ident { name, .. }) if name.as_ref() == "xs"));
+            }
+            _ => panic!("expected New"),
+        }
+    }
 }