@tishlang/tish 1.0.29 → 1.0.33

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_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_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"),
+        }
+    }
 }

package/crates/tish_parser/src/parser.rs

@@ -53,9 +53,9 @@ macro_rules! binary_multi_op {
 
 use tishlang_ast::{
     ArrowBody, ArrayElement, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
-    DestructProp, ExportDeclaration, Expr, ImportSpecifier, JsxAttrValue, JsxChild, JsxProp,
-    Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement, TypeAnnotation,
-    TypedParam, UnaryOp,
+    DestructProp, ExportDeclaration, Expr, FunParam, ImportSpecifier, JsxAttrValue, JsxChild,
+    JsxProp, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement,
+    TypeAnnotation, TypedParam, UnaryOp,
 };
 use tishlang_lexer::{Token, TokenKind};
 
@@ -363,6 +363,55 @@ impl<'a> Parser<'a> {
         self.expect(TokenKind::RBrace)?;
         Ok(DestructPattern::Object(props))
     }
+
+    /// One formal parameter: `name`, `name: T`, `name = expr`, or a destructuring pattern.
+    fn parse_fun_param(&mut self) -> Result<FunParam, String> {
+        if matches!(
+            self.peek_kind(),
+            Some(TokenKind::LBracket | TokenKind::LBrace)
+        ) {
+            let pattern = self.parse_destruct_pattern()?;
+            let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+                self.advance();
+                Some(self.parse_type_annotation()?)
+            } else {
+                None
+            };
+            let default = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
+                self.advance();
+                Some(self.parse_expr()?)
+            } else {
+                None
+            };
+            return Ok(FunParam::Destructure {
+                pattern,
+                type_ann,
+                default,
+            });
+        }
+        let param_name = self
+            .expect(TokenKind::Ident)?
+            .literal
+            .clone()
+            .ok_or("Expected param name")?;
+        let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+            self.advance();
+            Some(self.parse_type_annotation()?)
+        } else {
+            None
+        };
+        let default = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
+            self.advance();
+            Some(self.parse_expr()?)
+        } else {
+            None
+        };
+        Ok(FunParam::Simple(TypedParam {
+            name: param_name,
+            type_ann,
+            default,
+        }))
+    }
     
     /// Parse a type annotation (number, string, T[], {a: T}, etc.)
     fn parse_type_annotation(&mut self) -> Result<TypeAnnotation, String> {
@@ -480,26 +529,7 @@ impl<'a> Parser<'a> {
                 }
                 break;
             }
-            let param_name = self
-                .expect(TokenKind::Ident)?
-                .literal
-                .clone()
-                .ok_or("Expected param name")?;
-            // Optional type annotation
-            let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
-                self.advance();
-                Some(self.parse_type_annotation()?)
-            } else {
-                None
-            };
-            // Optional default value
-            let default = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
-                self.advance();
-                Some(self.parse_expr()?)
-            } else {
-                None
-            };
-            params.push(TypedParam { name: param_name, type_ann, default });
+            params.push(self.parse_fun_param()?);
             if !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
                 self.expect(TokenKind::Comma)?;
             }
@@ -1117,8 +1147,97 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn parse_postfix(&mut self) -> Result<Expr, String> {
+    /// Member chain (`.`, `?.`, `[]`) without consuming a call `(...)`.
+    fn parse_member_expression_no_call(&mut self) -> Result<Expr, String> {
         let mut expr = self.parse_primary()?;
+        while let Some(kind) = self.peek_kind() {
+            match kind {
+                TokenKind::Dot | TokenKind::OptionalChain => {
+                    let optional = kind == TokenKind::OptionalChain;
+                    self.advance();
+                    let prop = self
+                        .expect(TokenKind::Ident)?
+                        .literal
+                        .clone()
+                        .ok_or("Expected property name")?;
+                    let start = expr.span().start;
+                    let end = self.peek().map(|x| x.span.start).unwrap_or(start);
+                    expr = Expr::Member {
+                        object: Box::new(expr),
+                        prop: MemberProp::Name(prop),
+                        optional,
+                        span: Span { start, end },
+                    };
+                }
+                TokenKind::LBracket => {
+                    self.advance();
+                    let index = self.parse_expr()?;
+                    self.expect(TokenKind::RBracket)?;
+                    let start = expr.span().start;
+                    let end = self.peek().map(|x| x.span.start).unwrap_or(start);
+                    expr = Expr::Index {
+                        object: Box::new(expr),
+                        index: Box::new(index),
+                        optional: false,
+                        span: Span { start, end },
+                    };
+                }
+                _ => break,
+            }
+        }
+        Ok(expr)
+    }
+
+    /// ECMAScript `NewExpression`: `new` chains, then member expression without call, optional `(...)`.
+    fn parse_new_expression(&mut self) -> Result<Expr, String> {
+        if matches!(self.peek_kind(), Some(TokenKind::New)) {
+            let span_start = self.peek().map(|t| t.span.start).unwrap_or((0, 0));
+            self.advance();
+            let callee = Box::new(self.parse_new_expression()?);
+            let args = if matches!(self.peek_kind(), Some(TokenKind::LParen)) {
+                self.advance();
+                let mut args = Vec::new();
+                while !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                    if matches!(self.peek_kind(), Some(TokenKind::Spread)) {
+                        self.advance();
+                        let arg_expr = self.parse_expr()?;
+                        args.push(CallArg::Spread(arg_expr));
+                    } else {
+                        let arg_expr = self.parse_expr()?;
+                        args.push(CallArg::Expr(arg_expr));
+                    }
+                    if !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                        self.expect(TokenKind::Comma)?;
+                    }
+                }
+                self.expect(TokenKind::RParen)?;
+                args
+            } else {
+                Vec::new()
+            };
+            let end = self
+                .peek()
+                .map(|x| x.span.start)
+                .unwrap_or(callee.as_ref().span().end);
+            Ok(Expr::New {
+                callee,
+                args,
+                span: Span {
+                    start: span_start,
+                    end,
+                },
+            })
+        } else {
+            self.parse_member_expression_no_call()
+        }
+    }
+
+    fn parse_postfix(&mut self) -> Result<Expr, String> {
+        let mut expr = if matches!(self.peek_kind(), Some(TokenKind::New)) {
+            self.parse_new_expression()?
+        } else {
+            self.parse_primary()?
+        };
         while let Some(kind) = self.peek_kind() {
             match kind {
                 TokenKind::LParen => {
@@ -1243,7 +1362,11 @@ impl<'a> Parser<'a> {
                     let body = self.parse_arrow_body()?;
                     let end = self.previous_span_end();
                     return Ok(Expr::ArrowFunction {
-                        params: vec![TypedParam { name: name.clone(), type_ann: None, default: None }],
+                        params: vec![FunParam::Simple(TypedParam {
+                            name: name.clone(),
+                            type_ann: None,
+                            default: None,
+                        })],
                         body,
                         span: Span { start: span.start, end },
                     });
@@ -1418,39 +1541,26 @@ impl<'a> Parser<'a> {
                 is_arrow = true;
             }
         } else {
-            // Try to parse params: (x, y, z) or (x: Type, y: Type)
+            // Try to parse params: (x, y), ({ a }), ([a, b]), with optional types/defaults
+            let mut params_ok = true;
             loop {
-                if !matches!(self.peek_kind(), Some(TokenKind::Ident)) {
-                    break; // Not a valid arrow function param list
+                if matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                    break;
+                }
+                match self.parse_fun_param() {
+                    Ok(param) => params.push(param),
+                    Err(_) => {
+                        params_ok = false;
+                        break;
+                    }
                 }
-                let name = self.advance().unwrap().literal.clone().ok_or("Expected param name")?;
-                
-                // Optional type annotation
-                let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
-                    self.advance();
-                    Some(self.parse_type_annotation()?)
-                } else {
-                    None
-                };
-                
-                // Optional default value
-                let default = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
-                    self.advance();
-                    Some(self.parse_expr()?)
-                } else {
-                    None
-                };
-                
-                params.push(TypedParam { name, type_ann, default });
-                
                 if matches!(self.peek_kind(), Some(TokenKind::Comma)) {
                     self.advance();
                 } else {
                     break;
                 }
             }
-            
-            if matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+            if params_ok && matches!(self.peek_kind(), Some(TokenKind::RParen)) {
                 self.advance(); // consume )
                 if matches!(self.peek_kind(), Some(TokenKind::Arrow)) {
                     self.advance(); // consume =>
@@ -1787,6 +1897,7 @@ impl ExprSpan for Expr {
             Expr::Binary { span, .. } => *span,
             Expr::Unary { span, .. } => *span,
             Expr::Call { span, .. } => *span,
+            Expr::New { span, .. } => *span,
             Expr::Member { span, .. } => *span,
             Expr::Index { span, .. } => *span,
             Expr::Conditional { span, .. } => *span,

package/crates/tish_runtime/src/http.rs

@@ -1,12 +1,11 @@
 //! HTTP server + shared request parsing. Client `fetch` lives in `http_fetch.rs`.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 use tokio::runtime::Runtime;
 
 thread_local! {
@@ -80,7 +79,7 @@ pub(crate) fn extract_body(options: Option<&Value>) -> Option<String> {
 }
 
 pub(crate) fn build_error_response(error: &str) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(2);
+    let mut obj: ObjectMap = ObjectMap::with_capacity(2);
     obj.insert(Arc::from("error"), Value::String(error.into()));
     obj.insert(Arc::from("ok"), Value::Bool(false));
     Value::Object(Rc::new(RefCell::new(obj)))
@@ -147,7 +146,7 @@ pub fn create_server(port: u16) -> Result<tiny_http::Server, String> {
 }
 
 pub fn request_to_value(request: &mut tiny_http::Request) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(6);
+    let mut obj: ObjectMap = ObjectMap::with_capacity(6);
 
     obj.insert(
         Arc::from("method"),
@@ -164,7 +163,7 @@ pub fn request_to_value(request: &mut tiny_http::Request) -> Value {
     let query_string = request.url().split('?').nth(1).unwrap_or("");
     obj.insert(Arc::from("query"), Value::String(query_string.into()));
 
-    let mut headers_obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(request.headers().len());
+    let mut headers_obj: ObjectMap = ObjectMap::with_capacity(request.headers().len());
     for header in request.headers() {
         headers_obj.insert(
             Arc::from(header.field.as_str().as_str()),