@tishlang/tish 1.0.28 → 1.0.33

package/crates/tish_bytecode/src/compiler.rs

@@ -5,7 +5,8 @@ use std::sync::Arc;
 
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, DestructElement, DestructPattern, Expr,
-    JsxAttrValue, JsxChild, JsxProp, Literal, MemberProp, ObjectProp, Program, Span, Statement,
+    FunParam, JsxAttrValue, JsxChild, JsxProp, Literal, MemberProp, ObjectProp, Program, Span,
+    Statement,
 };
 
 use crate::chunk::{Chunk, Constant};
@@ -137,8 +138,14 @@ impl<'a> Compiler<'a> {
             if params.len() != 2 {
                 return None;
             }
-            let param_a = params[0].name.as_ref();
-            let param_b = params[1].name.as_ref();
+            let (param_a, param_b) = match (&params[0], &params[1]) {
+                (FunParam::Simple(a), FunParam::Simple(b))
+                    if a.default.is_none() && b.default.is_none() =>
+                {
+                    (a.name.as_ref(), b.name.as_ref())
+                }
+                _ => return None,
+            };
             let body_expr = match body {
                 ArrowBody::Expr(e) => e.as_ref(),
                 ArrowBody::Block(stmt) => {
@@ -184,8 +191,14 @@ impl<'a> Compiler<'a> {
             if params.len() != 2 {
                 return None;
             }
-            let param_a = params[0].name.as_ref();
-            let param_b = params[1].name.as_ref();
+            let (param_a, param_b) = match (&params[0], &params[1]) {
+                (FunParam::Simple(a), FunParam::Simple(b))
+                    if a.default.is_none() && b.default.is_none() =>
+                {
+                    (a.name.as_ref(), b.name.as_ref())
+                }
+                _ => return None,
+            };
             let body_expr = match body {
                 ArrowBody::Expr(e) => e.as_ref(),
                 ArrowBody::Block(stmt) => {
@@ -228,7 +241,10 @@ impl<'a> Compiler<'a> {
         if params.len() != 1 {
             return None;
         }
-        let param_name = params[0].name.as_ref();
+        let param_name = match &params[0] {
+            FunParam::Simple(tp) if tp.default.is_none() => tp.name.as_ref(),
+            _ => return None,
+        };
         let expr_ref: &Expr = match body {
             ArrowBody::Expr(e) => e.as_ref(),
             ArrowBody::Block(stmt) => {
@@ -277,7 +293,10 @@ impl<'a> Compiler<'a> {
         if params.len() != 1 {
             return None;
         }
-        let param_name = params[0].name.as_ref();
+        let param_name = match &params[0] {
+            FunParam::Simple(tp) if tp.default.is_none() => tp.name.as_ref(),
+            _ => return None,
+        };
         let expr_ref: &Expr = match body {
             ArrowBody::Expr(e) => e.as_ref(),
             ArrowBody::Block(stmt) => {
@@ -550,9 +569,22 @@ impl<'a> Compiler<'a> {
                 async_: _,
                 ..
             } => {
+                for p in params {
+                    if matches!(p, FunParam::Destructure { .. }) {
+                        return Err(CompileError {
+                            message: "Destructuring parameters are not supported in bytecode"
+                                .to_string(),
+                        });
+                    }
+                }
                 let mut inner = Chunk::new();
-                let mut param_names: Vec<Arc<str>> =
-                    params.iter().map(|p| Arc::clone(&p.name)).collect();
+                let mut param_names: Vec<Arc<str>> = params
+                    .iter()
+                    .map(|p| match p {
+                        FunParam::Simple(tp) => Arc::clone(&tp.name),
+                        _ => unreachable!(),
+                    })
+                    .collect();
                 if let Some(rp) = rest_param {
                     param_names.push(rp.name.clone());
                     inner.rest_param_index = (param_names.len() as u16).saturating_sub(1);
@@ -1061,9 +1093,22 @@ impl<'a> Compiler<'a> {
                 self.emit_u16(Opcode::Call, 1);
             }
             Expr::ArrowFunction { params, body, .. } => {
+                for p in params {
+                    if matches!(p, FunParam::Destructure { .. }) {
+                        return Err(CompileError {
+                            message: "Destructuring parameters are not supported in bytecode"
+                                .to_string(),
+                        });
+                    }
+                }
                 let mut inner = Chunk::new();
-                let param_names: Vec<Arc<str>> =
-                    params.iter().map(|p| Arc::clone(&p.name)).collect();
+                let param_names: Vec<Arc<str>> = params
+                    .iter()
+                    .map(|p| match p {
+                        FunParam::Simple(tp) => Arc::clone(&tp.name),
+                        _ => unreachable!(),
+                    })
+                    .collect();
                 for p in &param_names {
                     inner.add_name(Arc::clone(p));
                 }
@@ -1205,6 +1250,35 @@ impl<'a> Compiler<'a> {
                     message: "Logical assignment (&&=, ||=, ??=) not yet supported in bytecode".to_string(),
                 });
             }
+            Expr::New { callee, args, .. } => {
+                let has_spread = args.iter().any(|a| matches!(a, CallArg::Spread(_)));
+                if has_spread {
+                    self.emit_u16(Opcode::NewArray, 0);
+                    for arg in args {
+                        match arg {
+                            CallArg::Expr(e) => {
+                                self.compile_expr(e)?;
+                                self.emit_u16(Opcode::NewArray, 1);
+                                self.emit(Opcode::ConcatArray);
+                            }
+                            CallArg::Spread(expr) => {
+                                self.compile_expr(expr)?;
+                                self.emit(Opcode::ConcatArray);
+                            }
+                        }
+                    }
+                    self.compile_expr(callee)?;
+                    self.emit(Opcode::ConstructSpread);
+                } else {
+                    self.compile_expr(callee)?;
+                    for arg in args {
+                        if let CallArg::Expr(e) = arg {
+                            self.compile_expr(e)?;
+                        }
+                    }
+                    self.emit_u16(Opcode::Construct, args.len() as u16);
+                }
+            }
         }
         Ok(())
     }

package/crates/tish_bytecode/src/opcode.rs

@@ -80,13 +80,17 @@ pub enum Opcode {
     ArrayFilterBinOp = 35,
     /// Load built-in module export. Operands: u16 spec_const_idx, u16 export_name_const_idx. Pushes Value.
     LoadNativeExport = 36,
+    /// `new callee(...args)` (operand: u16 arg count). Stack: callee, then args — same as Call.
+    Construct = 37,
+    /// `new callee(...spread)` — stack: args array, then callee (same order as CallSpread).
+    ConstructSpread = 38,
 }
 
 impl Opcode {
-    /// Decode byte to opcode. Safe for b in 0..=36 (matches #[repr(u8)] discriminants).
+    /// Decode byte to opcode. Safe for b in 0..=38 (matches #[repr(u8)] discriminants).
     #[inline]
     pub fn from_u8(b: u8) -> Option<Opcode> {
-        if b <= 36 {
+        if b <= 38 {
             Some(unsafe { std::mem::transmute(b) })
         } else {
             None
@@ -97,7 +101,7 @@ impl Opcode {
     pub fn instruction_size(self, code: &[u8], ip: usize) -> Option<usize> {
         let size = match self {
             Opcode::Nop | Opcode::Pop | Opcode::Dup | Opcode::Return | Opcode::ExitTry
-            | Opcode::ArrayMapIdentity => 1,
+            | Opcode::ArrayMapIdentity | Opcode::CallSpread | Opcode::ConstructSpread => 1,
             Opcode::ArraySortByProperty | Opcode::ArrayMapBinOp | Opcode::ArrayFilterBinOp
             | Opcode::LoadNativeExport => 5,
             _ => 3,

package/crates/tish_compile/Cargo.toml

@@ -18,6 +18,7 @@ ws = []
 tishlang_ast = { path = "../tish_ast", 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"] }
 serde_json = "1.0"
 
 [dev-dependencies]