@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_compile/src/infer.rs

@@ -0,0 +1,292 @@
+//! 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,
+            name_span,
+            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(),
+                name_span: *name_span,
+                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,
+            name_span,
+            iterable,
+            body,
+            span,
+        } => {
+            ctx.push_scope();
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::ForOf {
+                name: name.clone(),
+                name_span: *name_span,
+                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,
+            name_span,
+            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(),
+                name_span: *name_span,
+                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

@@ -0,0 +1,164 @@
+//! Native compiler backend for Tish.
+//!
+//! Emits Rust source that links to tishlang_runtime.
+
+mod codegen;
+mod infer;
+mod resolve;
+mod types;
+
+/// How generated Rust is linked (desktop binary vs embedded iOS staticlib).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum NativeEmitMode {
+    #[default]
+    DesktopBin,
+    /// `[lib] crate-type = ["staticlib"]` — no `fn main()`, host calls `tish_ios_launch`.
+    EmbeddedLib,
+}
+
+pub use codegen::CompileError;
+pub use codegen::{
+    compile, compile_project, compile_project_full, compile_project_full_emit,
+    compile_with_features, compile_with_native_modules, compile_with_native_modules_emit,
+    compile_with_project_root,
+};
+pub use resolve::{
+    cargo_export_fn_name, compute_native_build_artifacts, detect_cycles, ensure_tish_canvas_module,
+    export_name_to_rust_ident, extract_native_import_features, format_rust_dependencies_toml,
+    generate_native_wrapper_rs, has_external_native_imports, has_native_imports,
+    infer_native_module_exports, is_builtin_native_spec, is_cargo_native_spec, is_native_import,
+    merge_modules, normalize_builtin_spec, program_uses_document, read_project_tish_config,
+    resolve_bare_spec, resolve_native_modules, resolve_project, resolve_project_from_stdin,
+    MergedProgram, NativeBuildArtifacts, NativeModuleInit, ResolvedNativeModule,
+};
+pub use types::{RustType, TypeContext};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tishlang_parser::parse;
+
+    #[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
+    for (let n of args) { total = total + n }
+    return total
+}
+"#;
+        let program = parse(src).unwrap();
+        let rust = compile(&program).unwrap();
+        // 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) {
+    let x = outerVar
+}
+"#;
+        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("ClassName"),
+            "expected emitted Rust to reference ClassName callable"
+        );
+    }
+
+    /// `value_call` must take `&Value` to a **local** (`let _callee = (<expr>).clone(); … &_callee`):
+    /// `&<temporary>` can dangle in release, and `let _callee = <ident>` would move globals like `Symbol`.
+    #[test]
+    fn native_emit_value_call_materializes_callee() {
+        use std::path::PathBuf;
+        let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        let path = manifest.join("../../tests/core/symbol.tish").canonicalize().unwrap();
+        let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+        assert!(
+            rust.contains("let _callee = (tishlang_runtime::get_index"),
+            "fixture should bracket-call via get_index with callee stored in a local"
+        );
+        assert!(
+            !rust.contains("let _callee = &tishlang_runtime::get_index"),
+            "expected callee materialization, found reference-to-temporary pattern"
+        );
+        assert!(
+            rust.contains("tishlang_runtime::value_call"),
+            "expected value_call via runtime re-export for nested Cargo builds"
+        );
+    }
+
+    #[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)
+        let features = ["http", "fs", "process", "regex"]
+            .into_iter()
+            .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("let mut outerVar: f64"),
+            "expected outerVar to be inferred as f64 (Copy, no clone needed)"
+        );
+    }
+}