@tishlang/tish 1.0.29 → 1.0.34

package/crates/tish_compile/src/infer.rs

@@ -0,0 +1,236 @@
+//! Type inference pass: annotates `VarDecl` nodes with inferred `TypeAnnotation`s
+//! where the user hasn't provided them, enabling codegen to emit native Rust types.
+//!
+//! Rules (conservative — only infer when unambiguous):
+//!   - Number literal init           → `number`
+//!   - String literal init           → `string`
+//!   - Bool literal init             → `boolean`
+//!   - Arithmetic of two `number` expressions → `number`
+//!   - Comparison of two `number` expressions → `boolean`
+//!   - Already-annotated vars are left unchanged.
+
+use std::collections::HashMap;
+use tishlang_ast::{
+    ArrowBody, BinOp, CallArg, Expr, FunParam, Literal, Program, Statement, TypeAnnotation,
+};
+
+/// Scoped type environment used during inference.
+#[derive(Default)]
+pub struct InferCtx {
+    scopes: Vec<HashMap<String, TypeAnnotation>>,
+}
+
+impl InferCtx {
+    pub fn new() -> Self {
+        Self { scopes: vec![HashMap::new()] }
+    }
+
+    fn push_scope(&mut self) {
+        self.scopes.push(HashMap::new());
+    }
+
+    fn pop_scope(&mut self) {
+        self.scopes.pop();
+    }
+
+    fn define(&mut self, name: &str, ty: TypeAnnotation) {
+        if let Some(s) = self.scopes.last_mut() {
+            s.insert(name.to_string(), ty);
+        }
+    }
+
+    pub fn lookup(&self, name: &str) -> Option<&TypeAnnotation> {
+        for s in self.scopes.iter().rev() {
+            if let Some(t) = s.get(name) {
+                return Some(t);
+            }
+        }
+        None
+    }
+}
+
+fn is_number(ann: &TypeAnnotation) -> bool {
+    matches!(ann, TypeAnnotation::Simple(s) if s.as_ref() == "number")
+}
+
+fn number_ann() -> TypeAnnotation {
+    TypeAnnotation::Simple("number".into())
+}
+
+fn string_ann() -> TypeAnnotation {
+    TypeAnnotation::Simple("string".into())
+}
+
+fn bool_ann() -> TypeAnnotation {
+    TypeAnnotation::Simple("boolean".into())
+}
+
+/// Infer the `TypeAnnotation` for an expression, if unambiguous.
+pub fn infer_expr_type(expr: &Expr, ctx: &InferCtx) -> Option<TypeAnnotation> {
+    match expr {
+        Expr::Literal { value, .. } => match value {
+            Literal::Number(_) => Some(number_ann()),
+            Literal::String(_) => Some(string_ann()),
+            Literal::Bool(_) => Some(bool_ann()),
+            Literal::Null => None,
+        },
+        Expr::Ident { name, .. } => ctx.lookup(name.as_ref()).cloned(),
+        Expr::Binary { left, op, right, .. } => {
+            let lt = infer_expr_type(left, ctx)?;
+            let rt = infer_expr_type(right, ctx)?;
+            if is_number(&lt) && is_number(&rt) {
+                match op {
+                    BinOp::Add
+                    | BinOp::Sub
+                    | BinOp::Mul
+                    | BinOp::Div
+                    | BinOp::Mod
+                    | BinOp::Pow => Some(number_ann()),
+                    BinOp::Lt
+                    | BinOp::Le
+                    | BinOp::Gt
+                    | BinOp::Ge
+                    | BinOp::StrictEq
+                    | BinOp::StrictNe => Some(bool_ann()),
+                    _ => None,
+                }
+            } else {
+                None
+            }
+        }
+        Expr::Unary { op, operand, .. } => {
+            use tishlang_ast::UnaryOp;
+            match op {
+                UnaryOp::Neg | UnaryOp::Pos => {
+                    let t = infer_expr_type(operand, ctx)?;
+                    if is_number(&t) { Some(number_ann()) } else { None }
+                }
+                UnaryOp::Not => Some(bool_ann()),
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
+/// Run inference over a program, returning a modified Program with additional
+/// type annotations filled in on `VarDecl` nodes.
+pub fn infer_program(program: &Program) -> Program {
+    let mut ctx = InferCtx::new();
+    Program { statements: infer_statements(&program.statements, &mut ctx) }
+}
+
+fn infer_statements(stmts: &[Statement], ctx: &mut InferCtx) -> Vec<Statement> {
+    stmts.iter().map(|s| infer_statement(s, ctx)).collect()
+}
+
+fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
+    match stmt {
+        Statement::VarDecl { name, mutable, type_ann, init, span } => {
+            // Already annotated — propagate into ctx but don't change the node.
+            if let Some(ann) = type_ann {
+                ctx.define(name.as_ref(), ann.clone());
+                return stmt.clone();
+            }
+            // Try to infer from init expression.
+            let inferred = init.as_ref().and_then(|e| infer_expr_type(e, ctx));
+            if let Some(ref ann) = inferred {
+                ctx.define(name.as_ref(), ann.clone());
+            }
+            Statement::VarDecl {
+                name: name.clone(),
+                mutable: *mutable,
+                type_ann: inferred,
+                init: init.clone(),
+                span: *span,
+            }
+        }
+        Statement::Block { statements, span } => {
+            ctx.push_scope();
+            let stmts = infer_statements(statements, ctx);
+            ctx.pop_scope();
+            Statement::Block { statements: stmts, span: *span }
+        }
+        Statement::For { init, cond, update, body, span } => {
+            // Scope for loop variable
+            ctx.push_scope();
+            let new_init = init.as_ref().map(|i| Box::new(infer_statement(i, ctx)));
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::For {
+                init: new_init,
+                cond: cond.clone(),
+                update: update.clone(),
+                body: new_body,
+                span: *span,
+            }
+        }
+        Statement::ForOf { name, iterable, body, span } => {
+            ctx.push_scope();
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::ForOf {
+                name: name.clone(),
+                iterable: iterable.clone(),
+                body: new_body,
+                span: *span,
+            }
+        }
+        Statement::While { cond, body, span } => {
+            ctx.push_scope();
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::While { cond: cond.clone(), body: new_body, span: *span }
+        }
+        Statement::DoWhile { body, cond, span } => {
+            ctx.push_scope();
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::DoWhile { body: new_body, cond: cond.clone(), span: *span }
+        }
+        Statement::If { cond, then_branch, else_branch, span } => {
+            let new_then = Box::new(infer_statement(then_branch, ctx));
+            let new_else = else_branch.as_ref().map(|e| Box::new(infer_statement(e, ctx)));
+            Statement::If {
+                cond: cond.clone(),
+                then_branch: new_then,
+                else_branch: new_else,
+                span: *span,
+            }
+        }
+        Statement::FunDecl { async_, name, params, rest_param, return_type, body, span } => {
+            ctx.push_scope();
+            for p in params {
+                if let FunParam::Simple(tp) = p {
+                    if let Some(ann) = &tp.type_ann {
+                        ctx.define(tp.name.as_ref(), ann.clone());
+                    }
+                }
+            }
+            if let Some(rp) = rest_param {
+                if let Some(ann) = &rp.type_ann {
+                    ctx.define(rp.name.as_ref(), ann.clone());
+                }
+            }
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::FunDecl {
+                async_: *async_,
+                name: name.clone(),
+                params: params.clone(),
+                rest_param: rest_param.clone(),
+                return_type: return_type.clone(),
+                body: new_body,
+                span: *span,
+            }
+        }
+        // For statements with no interesting sub-structure, clone as-is.
+        _ => stmt.clone(),
+    }
+}
+
+// Suppress unused import warning — CallArg is used indirectly via tishlang_ast.
+#[allow(dead_code)]
+fn _uses_call_arg(_: &CallArg) {}
+#[allow(dead_code)]
+fn _uses_arrow_body(_: &ArrowBody) {}

package/crates/tish_compile/src/lib.rs

@@ -3,6 +3,7 @@
 //! Emits Rust source that links to tishlang_runtime.
 
 mod codegen;
+mod infer;
 mod resolve;
 mod types;
 
@@ -25,6 +26,9 @@ mod tests {
 
     #[test]
     fn typed_assign_conversion() {
+        // With the inference pass and native emit, `total: number = 0` becomes f64.
+        // Assignment `total = total + n` (where n comes from ForOf over a Value::Array)
+        // emits a native f64 assignment that unboxes the Value result via from_value_expr.
         let src = r#"
 fn sum(...args: number[]): number {
     let total: number = 0
@@ -34,11 +38,16 @@ fn sum(...args: number[]): number {
 "#;
         let program = parse(src).unwrap();
         let rust = compile(&program).unwrap();
-        assert!(rust.contains("match &_v { Value::Number(n) => *n"), "expected typed assign conversion");
+        // total should be declared as f64
+        assert!(rust.contains("let mut total: f64"), "expected total: f64");
+        // The return value of run() should convert total back to Value
+        assert!(rust.contains("Value::Number(total)"), "expected Value::Number(total) wrapping");
     }
 
     #[test]
     fn loop_var_decl_clone_outer_var() {
+        // With inference, outerVar = 42 gets inferred as f64. f64 is Copy, so no clone is
+        // needed — direct assignment is correct. The test verifies compilation succeeds.
         let src = r#"
 let outerVar = 42
 for (let i = 0; i < 5; i = i + 1) {
@@ -47,14 +56,51 @@ for (let i = 0; i < 5; i = i + 1) {
 "#;
         let program = parse(src).unwrap();
         let rust = compile(&program).unwrap();
+        // outerVar and x are f64 (inferred) — Copy assignment, no .clone() needed.
+        assert!(rust.contains("let mut outerVar: f64"), "expected outerVar: f64");
+        assert!(rust.contains("let mut x: f64"), "expected x: f64");
+    }
+
+    #[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("(outerVar).clone()"),
-            "expected outerVar to be cloned in loop body"
+            rust.contains("ClassName"),
+            "expected emitted Rust to reference ClassName callable"
         );
     }
 
     #[test]
     fn loop_var_decl_clone_via_project_full() {
+        // With the inference pass, `let outerVar = 42` is inferred as f64 (Copy) — no clone needed.
+        // This test verifies the full benchmark_granular project compiles and that outerVar
+        // is emitted as the inferred f64 type rather than requiring a Value clone.
         let manifest = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         let bench = manifest.join("../../tests/core/benchmark_granular.tish").canonicalize().unwrap();
         // Use same default features as tish CLI (http, fs, process, regex)
@@ -63,9 +109,10 @@ for (let i = 0; i < 5; i = i + 1) {
             .map(String::from)
             .collect::<Vec<_>>();
         let (rust, _) = compile_project_full(&bench, bench.parent(), &features, true).unwrap();
+        // outerVar = 42 is inferred as f64; f64 is Copy so no .clone() is emitted.
         assert!(
-            rust.contains("(outerVar).clone()"),
-            "expected outerVar to be cloned in benchmark_granular loop"
+            rust.contains("let mut outerVar: f64"),
+            "expected outerVar to be inferred as f64 (Copy, no clone needed)"
         );
     }
 }

package/crates/tish_compile/src/types.rs

@@ -4,7 +4,7 @@
 
 use std::collections::HashMap;
 use std::sync::Arc;
-use tishlang_ast::TypeAnnotation;
+use tishlang_ast::{BinOp, TypeAnnotation};
 
 /// Concrete Rust type representation for code generation.
 #[derive(Debug, Clone, PartialEq)]
@@ -89,6 +89,38 @@ impl RustType {
         !matches!(self, RustType::Value)
     }
 
+    /// Check if this type is numeric (f64).
+    pub fn is_numeric(&self) -> bool {
+        matches!(self, RustType::F64)
+    }
+
+    /// Infer the result type of a binary operation given the operand types.
+    /// Returns `None` if native code cannot be emitted (fall back to Value path).
+    pub fn result_type_of_binop(op: BinOp, lhs: &RustType, rhs: &RustType) -> Option<RustType> {
+        if lhs == &RustType::F64 && rhs == &RustType::F64 {
+            match op {
+                BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div | BinOp::Mod | BinOp::Pow => {
+                    Some(RustType::F64)
+                }
+                BinOp::Lt
+                | BinOp::Le
+                | BinOp::Gt
+                | BinOp::Ge
+                | BinOp::StrictEq
+                | BinOp::StrictNe => Some(RustType::Bool),
+                _ => None,
+            }
+        } else if lhs == &RustType::Bool && rhs == &RustType::Bool {
+            match op {
+                BinOp::And | BinOp::Or => Some(RustType::Bool),
+                BinOp::StrictEq | BinOp::StrictNe => Some(RustType::Bool),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+
     /// Get the Rust type string for code generation.
     pub fn to_rust_type_str(&self) -> String {
         match self {
@@ -169,14 +201,19 @@ impl RustType {
         match self {
             RustType::Value => native_expr.to_string(),
             RustType::F64 => format!("Value::Number({})", native_expr),
-            RustType::String => format!("Value::String({}.into())", native_expr),
+            RustType::String => format!("Value::String({}.clone().into())", native_expr),
             RustType::Bool => format!("Value::Bool({})", native_expr),
             RustType::Unit => "Value::Null".to_string(),
             RustType::Vec(inner) => {
-                let inner_to_value = inner.to_value_expr("v");
+                // Use iter()/copied()/cloned() to avoid moving the vector.
+                let (iter_suffix, val_expr) = match inner.as_ref() {
+                    RustType::F64 => (".iter().copied()", "Value::Number(v)".to_string()),
+                    RustType::Bool => (".iter().copied()", "Value::Bool(v)".to_string()),
+                    _ => (".iter().cloned()", inner.to_value_expr("v")),
+                };
                 format!(
-                    "Value::Array(Rc::new(RefCell::new({}.into_iter().map(|v| {}).collect())))",
-                    native_expr, inner_to_value
+                    "Value::Array(Rc::new(RefCell::new({}{}.map(|v| {}).collect())))",
+                    native_expr, iter_suffix, val_expr
                 )
             }
             RustType::Option(inner) => {

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;