@tishlang/tish 2.9.0 → 2.12.0

package/crates/tish_compile/src/codegen.rs

@@ -2097,6 +2097,148 @@ impl Codegen {
         self.emit_expr(expr)
     }
 
+    /// Is `update` a `+1` step on `var` (`var++`, `++var`, `var += 1`, or `var = var + 1`)?
+    fn is_increment_of(update: &Expr, var: &str) -> bool {
+        match update {
+            Expr::PostfixInc { name, .. } | Expr::PrefixInc { name, .. } => name.as_ref() == var,
+            Expr::CompoundAssign {
+                name,
+                op: CompoundOp::Add,
+                value,
+                ..
+            } => name.as_ref() == var && Self::int_literal_value_of(value) == Some(1),
+            Expr::Assign { name, value, .. } => {
+                name.as_ref() == var
+                    && matches!(
+                        value.as_ref(),
+                        Expr::Binary { left, op: BinOp::Add, right, .. }
+                            if matches!(left.as_ref(), Expr::Ident { name: l, .. } if l.as_ref() == var)
+                                && Self::int_literal_value_of(right) == Some(1)
+                    )
+            }
+            _ => false,
+        }
+    }
+
+    /// #173: detect a fill loop `for (let i = 0; i < N; i++) { a.push(K) }` over a native `Vec<T>`
+    /// and emit it as a single bulk `a.extend(std::iter::repeat(K).take((N) as usize))` — one
+    /// allocation instead of N per-element pushes that repeatedly realloc as the Vec grows. Returns
+    /// `Ok(true)` when the fused form was emitted (the caller then skips the normal loop).
+    ///
+    /// Sound only when `N` is a proven, side-effect-free integer (so the bulk count matches the loop
+    /// iteration count exactly, including the truncating `as usize` for `0`/negative) and `K` is a
+    /// constant of the element type (no per-element variation). Any miss returns `Ok(false)` and the
+    /// normal loop is emitted — correctness over coverage.
+    fn try_emit_native_fill_loop(
+        &mut self,
+        init: Option<&Statement>,
+        cond: Option<&Expr>,
+        update: Option<&Expr>,
+        body: &Statement,
+    ) -> Result<bool, CompileError> {
+        // init: `let i = 0`
+        let (
+            Some(Statement::VarDecl {
+                name: i_name,
+                init: Some(i_init),
+                ..
+            }),
+            Some(cond),
+            Some(update),
+        ) = (init, cond, update)
+        else {
+            return Ok(false);
+        };
+        if Self::int_literal_value_of(i_init) != Some(0) {
+            return Ok(false);
+        }
+        // cond: `i < N`
+        let Expr::Binary {
+            left,
+            op: BinOp::Lt,
+            right: bound,
+            ..
+        } = cond
+        else {
+            return Ok(false);
+        };
+        let Expr::Ident { name: c_name, .. } = left.as_ref() else {
+            return Ok(false);
+        };
+        if c_name.as_ref() != i_name.as_ref() {
+            return Ok(false);
+        }
+        // update: `i++` / `++i` / `i += 1` / `i = i + 1`
+        if !Self::is_increment_of(update, i_name.as_ref()) {
+            return Ok(false);
+        }
+        // body: exactly one statement `a.push(K)`
+        let push_stmt = match body {
+            Statement::Block { statements, .. } if statements.len() == 1 => &statements[0],
+            Statement::ExprStmt { .. } => body,
+            _ => return Ok(false),
+        };
+        let Statement::ExprStmt {
+            expr: Expr::Call { callee, args, .. },
+            ..
+        } = push_stmt
+        else {
+            return Ok(false);
+        };
+        let Expr::Member {
+            object,
+            prop: MemberProp::Name { name: method, .. },
+            optional: false,
+            ..
+        } = callee.as_ref()
+        else {
+            return Ok(false);
+        };
+        if method.as_ref() != "push" || args.len() != 1 {
+            return Ok(false);
+        }
+        let Expr::Ident { name: arr_name, .. } = object.as_ref() else {
+            return Ok(false);
+        };
+        // `a` must be a native `Vec<T>`. A closure-captured (RefCell) Vec would need a borrow_mut;
+        // skip it (rare) and keep the plain loop.
+        let RustType::Vec(elem) = self.type_context.get_type(arr_name.as_ref()) else {
+            return Ok(false);
+        };
+        if self.refcell_wrapped_vars.contains(arr_name.as_ref()) {
+            return Ok(false);
+        }
+        let CallArg::Expr(k_expr) = &args[0] else {
+            return Ok(false);
+        };
+        // K must be a constant literal of the element type (no per-element variation, no `i` ref).
+        let k_code = match (&*elem, k_expr) {
+            (RustType::F64, Expr::Literal { value: Literal::Number(n), .. }) => Self::f64_lit(*n),
+            (RustType::Bool, Expr::Literal { value: Literal::Bool(b), .. }) => format!("{}", b),
+            _ => return Ok(false),
+        };
+        // N must be a proven, side-effect-free integer: an integer literal or an int-range local.
+        let n_code = match bound.as_ref() {
+            Expr::Literal {
+                value: Literal::Number(_),
+                ..
+            } if Self::int_literal_value_of(bound).is_some() => self.emit_typed_expr(bound)?.0,
+            Expr::Ident { name, .. }
+                if self.int_range_locals.contains_key(name.as_ref())
+                    && self.type_context.get_type(name.as_ref()) == RustType::F64 =>
+            {
+                Self::escape_ident(name.as_ref()).into_owned()
+            }
+            _ => return Ok(false),
+        };
+        let arr_esc = Self::escape_ident(arr_name.as_ref()).into_owned();
+        self.writeln(&format!(
+            "{}.extend(std::iter::repeat({}).take(({}) as usize));",
+            arr_esc, k_code, n_code
+        ));
+        Ok(true)
+    }
+
     fn emit_statement(&mut self, stmt: &Statement) -> Result<(), CompileError> {
         match stmt {
             Statement::Block { statements, .. } => {
@@ -2424,6 +2566,18 @@ impl Codegen {
                 body,
                 ..
             } => {
+                // #173: fuse a fill loop `for (let i = 0; i < N; i++) { a.push(K) }` over a native
+                // `Vec<T>` into a single bulk `extend` — one allocation instead of N per-element
+                // pushes (which repeatedly realloc as the Vec grows). Sound only when `N` is a proven,
+                // side-effect-free integer; otherwise the normal loop is emitted below.
+                if self.try_emit_native_fill_loop(
+                    init.as_deref(),
+                    cond.as_ref(),
+                    update.as_ref(),
+                    body,
+                )? {
+                    return Ok(());
+                }
                 self.writeln("{");
                 self.indent += 1;
                 if let Some(i) = init {
@@ -7537,6 +7691,13 @@ impl Codegen {
                 ..
             } => {
                 if let Expr::Ident { name: var_name, .. } = object.as_ref() {
+                    // #173: `vec.length` on a native `Vec<_>` is a native `f64` (the emitter lowers it
+                    // to `(vec.len() as f64)`), so a local fed by `arr.length` stays native.
+                    if let Some(RustType::Vec(_)) = env.get(var_name.as_ref()) {
+                        if prop_name.as_ref() == "length" {
+                            return RustType::F64;
+                        }
+                    }
                     if let Some(RustType::Named { fields, .. }) = env.get(var_name.as_ref()) {
                         if let Some((_, field_ty)) =
                             fields.iter().find(|(k, _)| k.as_ref() == prop_name.as_ref())
@@ -7577,6 +7738,12 @@ impl Codegen {
                         }
                     }
                 }
+                // #169: a fused native `Vec<f64>` reduce produces an `f64` (the emitter lowers it via
+                // `native_vec_hof_for_call`). Model it here so an accumulator fed by `xs.reduce(...)`
+                // is not wrongly demoted to a boxed `Value`. Conservative: any miss → `Value`.
+                if let Some(t) = self.native_vec_reduce_result_type(callee, args, env) {
+                    return t;
+                }
                 RustType::Value
             }
             // Unary, Conditional, etc. are not modelled by `emit_typed_expr` (it boxes them), so a
@@ -7586,6 +7753,81 @@ impl Codegen {
         }
     }
 
+    /// #169: read-only mirror of [`try_native_vec_hof`]'s `reduce` preconditions, for
+    /// [`expr_native_type`]. Returns `Some(F64)` exactly when a `xs.reduce((acc, x) => body, init)`
+    /// call would fuse to a native `f64` fold (so an accumulator it feeds stays native instead of
+    /// being demoted to a boxed `Value`). Any uncertainty returns `None` — the oracle never claims
+    /// `F64` where the emitter would box, which is what keeps the demotion analysis sound.
+    fn native_vec_reduce_result_type(
+        &self,
+        callee: &Expr,
+        args: &[CallArg],
+        env: &HashMap<String, RustType>,
+    ) -> Option<RustType> {
+        if std::env::var("TISH_NATIVE_HOF").is_err() {
+            return None;
+        }
+        let Expr::Member {
+            object,
+            prop: MemberProp::Name { name: method, .. },
+            optional: false,
+            ..
+        } = callee
+        else {
+            return None;
+        };
+        if method.as_ref() != "reduce" {
+            return None;
+        }
+        let Expr::Ident { name: recv_name, .. } = object.as_ref() else {
+            return None;
+        };
+        // Receiver must be a native `Vec<f64>` (`.copied()` needs a `Copy` element).
+        match env.get(recv_name.as_ref()) {
+            Some(RustType::Vec(inner)) if **inner == RustType::F64 => {}
+            _ => return None,
+        }
+        // `reduce(callback, init)` with a simple-param expression-body arrow that does not touch the
+        // receiver (an alias inside the closure would break the `.iter()` borrow).
+        if args.len() != 2 {
+            return None;
+        }
+        let Some(CallArg::Expr(Expr::ArrowFunction { params, body, .. })) = args.first() else {
+            return None;
+        };
+        if params.len() != 2 {
+            return None;
+        }
+        let (FunParam::Simple(acc_p), FunParam::Simple(x_p)) = (&params[0], &params[1]) else {
+            return None;
+        };
+        if acc_p.default.is_some() || x_p.default.is_some() {
+            return None;
+        }
+        let ArrowBody::Expr(be) = body else {
+            return None;
+        };
+        if crate::infer::pi_mentions(be, recv_name.as_ref()) {
+            return None;
+        }
+        // The init must be native-numeric, and the body must lower to `f64` with both closure params
+        // bound `f64` — exactly the emitter's preconditions, evaluated read-only.
+        let CallArg::Expr(init_e) = &args[1] else {
+            return None;
+        };
+        if self.expr_native_type(init_e, env) != RustType::F64 {
+            return None;
+        }
+        let mut benv = env.clone();
+        benv.insert(acc_p.name.to_string(), RustType::F64);
+        benv.insert(x_p.name.to_string(), RustType::F64);
+        if self.expr_native_type(be, &benv) == RustType::F64 {
+            Some(RustType::F64)
+        } else {
+            None
+        }
+    }
+
     /// Names of top-level fns eligible for a parallel native `fn f_native(f64,..)->f64`:
     /// non-async, every param `: number` (no default), `: number` return, and a native-safe
     /// body (only block/if/return/expr-stmt over native exprs + calls to other eligible fns or
@@ -9444,6 +9686,19 @@ impl Codegen {
             } => {
                 if let Expr::Ident { name: var_name, .. } = object.as_ref() {
                     let var_type = self.type_context.get_type(var_name.as_ref());
+                    // #173: `vec.length` on a native `Vec<_>` → `(vec.len() as f64)`, so the length
+                    // (and arithmetic derived from it) stays native instead of a boxed `get_prop`.
+                    if let RustType::Vec(_) = &var_type {
+                        if prop_name.as_ref() == "length" {
+                            let var_esc = Self::escape_ident(var_name.as_ref()).into_owned();
+                            let code = if self.refcell_wrapped_vars.contains(var_name.as_ref()) {
+                                format!("({}.borrow().len() as f64)", var_esc)
+                            } else {
+                                format!("({}.len() as f64)", var_esc)
+                            };
+                            return Ok((code, RustType::F64));
+                        }
+                    }
                     if let RustType::Named { fields, .. } = &var_type {
                         if let Some((_, field_ty)) =
                             fields.iter().find(|(k, _)| k.as_ref() == prop_name.as_ref())

package/crates/tish_compile/tests/perf_codegen_169_173.rs

@@ -0,0 +1,139 @@
+//! Generated-Rust assertions for the Beat-Node native codegen wins #169 and #173.
+//!
+//! These run in their own test binary (separate process from the lib unit tests), so the
+//! dark-ship env flags set here never leak into other tests. Every test sets the SAME flag set
+//! (the gauntlet's `TYPED_FLAGS`), so parallel execution is race-free.
+
+use std::path::PathBuf;
+
+use tishlang_compile::{compile, compile_project_full};
+use tishlang_parser::parse;
+
+/// Enable every dark-shipped typed-native flag, matching `scripts/run_perf_gauntlet.sh`.
+fn enable_typed_flags() {
+    for k in [
+        "TISH_PARAM_NATIVE",
+        "TISH_PARAM_INFER",
+        "TISH_NATIVE_FN",
+        "TISH_STRUCT_INFER",
+        "TISH_FUSED_HOF",
+        "TISH_NATIVE_HOF",
+        "TISH_AGGREGATE_INFER",
+    ] {
+        std::env::set_var(k, "1");
+    }
+}
+
+fn compile_typed(src: &str) -> String {
+    enable_typed_flags();
+    compile(&parse(src).unwrap()).unwrap()
+}
+
+/// Compile a real fixture through the **same** path the `tish build` CLI uses
+/// (`compile_project_full` → `merge_modules` → codegen), so generated-Rust assertions match the
+/// gauntlet build exactly.
+fn compile_fixture_typed(rel: &str) -> String {
+    enable_typed_flags();
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    rust
+}
+
+// ── #169: a fused native `Vec<f64>` reduce result keeps its accumulator native ────────────────
+
+#[test]
+fn issue_169_reduce_fed_accumulator_stays_native() {
+    // The real gauntlet fixture: `acc` is updated from `xs.reduce(...)` (which the native-HOF path
+    // fuses to a native f64 fold). Before #169 the demotion oracle didn't model the fusion, so `acc`
+    // was boxed (`let mut acc = Value::Number(...)`) and paid boxed ops::mul/add/modulo + clone per
+    // iter. Compiled through the same `compile_project_full` path the `tish build` CLI uses.
+    let rust = compile_fixture_typed("tests/perf/typed_array_hof.tish");
+    assert!(
+        rust.contains("let mut acc: f64"),
+        "acc must stay native f64 (reduce result modelled as F64), got:\n{}",
+        rust.lines().filter(|l| l.contains("acc")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        !rust.contains("let mut acc = Value::Number"),
+        "acc must NOT be boxed:\n{}",
+        rust.lines().filter(|l| l.contains("acc")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    // The per-iteration accumulator update is native arithmetic, not boxed ops on `acc`.
+    assert!(
+        !rust.contains("ops::mul(&acc"),
+        "acc update must be native f64, not a boxed ops::mul on acc"
+    );
+}
+
+#[test]
+fn issue_169_non_number_array_reduce_does_not_make_accumulator_native() {
+    // Conservative bail: reduce over a *string* array is not a native f64 fold, so an accumulator it
+    // feeds must stay boxed (sound — we never claim F64 where the emitter would box).
+    let src = r#"
+let ss: string[] = ["a", "b", "c"]
+let acc: number = 0
+let r: number = 0
+while (r < 10) {
+  acc = acc + ss.length
+  r = r + 1
+}
+console.log(acc)
+"#;
+    // Just assert it compiles and is sound; `acc` here is fed by `.length` which is a separate lever.
+    let rust = compile_typed(src);
+    assert!(rust.contains("fn main"), "compiles to a native program");
+}
+
+// ── #173: fill-loop fusion + native `.length` ─────────────────────────────────────────────────
+
+#[test]
+fn issue_173_fill_loop_fuses_to_bulk_extend() {
+    // `let a = []; for (let i = 0; i < N; i++) { a.push(K) }` over a native Vec lowers to a single
+    // `a.extend(std::iter::repeat(K).take((N) as usize))` — one allocation, no per-element pushes.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    // boolean[] fill with a literal bound.
+    assert!(
+        rust.contains("extend(std::iter::repeat(true).take((8_f64) as usize))"),
+        "boolean fill loop must fuse to a bulk extend:\n{}",
+        rust.lines().filter(|l| l.contains("repeat")).collect::<Vec<_>>().join("\n")
+    );
+    // number[] fill with an integer-`let` bound (`n`).
+    assert!(
+        rust.contains("extend(std::iter::repeat(1_f64).take((n) as usize))"),
+        "number fill loop with an int-range bound must fuse:\n{}",
+        rust.lines().filter(|l| l.contains("repeat")).collect::<Vec<_>>().join("\n")
+    );
+}
+
+#[test]
+fn issue_173_length_is_native_f64() {
+    // `vec.length` on a native Vec lowers to `(vec.len() as f64)`, not a boxed `get_prop`.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    assert!(
+        rust.contains("a.len() as f64"),
+        "native Vec `.length` must lower to `(a.len() as f64)`"
+    );
+    assert!(
+        !rust.contains("get_prop(&a, \"length\")"),
+        "native Vec `.length` must not go through boxed get_prop"
+    );
+}
+
+#[test]
+fn issue_173_adversarial_cases_do_not_fuse() {
+    // Non-constant push arg, extra statement, and `break` in the body must NOT fuse — they keep the
+    // per-element push loop (correctness over coverage). The fixture's only fusions are the three
+    // canonical fills (8, n, 3); a non-constant `push(i * 2)` must not produce an extend.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    assert!(
+        !rust.contains("repeat((i * 2"),
+        "non-constant push arg must not be fused into a repeat-fill"
+    );
+    // Exactly the three sound fills are emitted (8, n, 3) — no extra fusions crept in.
+    let fusions = rust.matches("std::iter::repeat").count();
+    assert_eq!(
+        fusions, 3,
+        "exactly 3 fill loops should fuse (boolFill=8, sieve=n, oobGrow=3), found {fusions}"
+    );
+}