@tishlang/tish 1.13.2 → 2.0.1

package/crates/tish_native/src/build.rs

@@ -16,6 +16,7 @@ const RUNTIME_CARGO_FEATURES: &[&str] = &[
     "process",
     "regex",
     "ws",
+    "tty",
 ];
 
 /// Map CLI/compile features to flags passed to `tishlang_runtime` in the temp crate's Cargo.toml.
@@ -71,6 +72,32 @@ fn inject_generated_native_mod(rust_code: &str) -> String {
     }
 }
 
+/// Whether to embed mimalloc as the `#[global_allocator]` of rust-AOT BINARY output. tish workloads
+/// are allocation-bound (a sampling profile of object/array code spends most time in malloc/free — see
+/// `docs/perf.md`); mimalloc gives ~20% on object/array/bundle code, the same lever as the `tish` CLI's
+/// own `fast-alloc` and the reason JSC ships bmalloc. Default ON; `TISH_NATIVE_FAST_ALLOC=0` opts out
+/// (e.g. a target whose C toolchain can't build mimalloc). Callers also skip it for staticlib output (a
+/// library does not own the final program's allocator) and cross builds (avoid cross-compiling C).
+fn fast_alloc_enabled() -> bool {
+    std::env::var("TISH_NATIVE_FAST_ALLOC")
+        .map(|v| v != "0")
+        .unwrap_or(true)
+}
+
+/// Insert a mimalloc `#[global_allocator]` into the generated crate root, after the leading
+/// `#![allow(...)]` inner attribute (mirrors [`inject_generated_native_mod`]; an inner attribute must
+/// precede any item, and the codegen emits exactly one — `#![allow(unused, non_snake_case)]`).
+fn inject_global_allocator(rust_code: &str) -> String {
+    const STMT: &str =
+        "#[global_allocator]\nstatic TISH_GLOBAL_ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;\n\n";
+    if let Some(pos) = rust_code.find("\n\n") {
+        let (a, b) = rust_code.split_at(pos + 2);
+        format!("{a}{STMT}{b}")
+    } else {
+        format!("{rust_code}\n\n{STMT}")
+    }
+}
+
 pub(crate) fn rust_code_needs_tokio(rust_code: &str) -> bool {
     rust_code.contains("#[tokio::main]") || rust_code.contains("tokio::runtime::Runtime")
 }
@@ -96,6 +123,7 @@ pub fn build_via_cargo(
     )
 }
 
+#[allow(clippy::too_many_arguments)] // orthogonal cargo build inputs; bundling would just relocate the same fields
 pub fn build_via_cargo_with_config(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
@@ -140,7 +168,7 @@ pub fn build_via_cargo_with_config(
         .collect();
 
     let mut more_deps = String::new();
-    more_deps.push_str(&tokio_dep);
+    more_deps.push_str(tokio_dep);
     if !native_deps.is_empty() {
         more_deps.push_str(&format!("\n{}", native_deps));
     }
@@ -154,6 +182,21 @@ pub fn build_via_cargo_with_config(
         rust_code.to_string()
     };
 
+    // mimalloc as the program's global allocator — binary output only (a staticlib does not own the
+    // allocator), native only (don't cross-compile mimalloc's C). Adds one cached dep + a global_alloc
+    // statement; semantically transparent. `TISH_NATIVE_FAST_ALLOC=0` opts out.
+    let use_fast_alloc = fast_alloc_enabled()
+        && build_config.artifact != NativeArtifact::StaticLib
+        && build_config.cargo_target.is_none();
+    if use_fast_alloc {
+        more_deps.push_str("\nmimalloc = \"0.1\"\n");
+    }
+    let rust_main = if use_fast_alloc {
+        inject_global_allocator(&rust_main)
+    } else {
+        rust_main
+    };
+
     let tish_ui_path = std::path::Path::new(&runtime_path)
         .parent()
         .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
@@ -258,6 +301,7 @@ tishlang_runtime = {{ path = {:?}{} }}
 ///
 /// `bins` order must match `outputs`: each `(stem, rust_code, generated_native_rs)` pairs with
 /// `outputs[i].0` (entry path — used only for validation) and `outputs[i].1` (final binary path).
+#[allow(clippy::too_many_arguments)] // orthogonal batch-build inputs (bins/outputs/modules/flags)
 pub(crate) fn build_many_via_cargo(
     bins: Vec<(String, String, Option<String>)>,
     native_modules: Vec<ResolvedNativeModule>,
@@ -322,6 +366,11 @@ pub(crate) fn build_many_via_cargo(
     if !extra_dependencies_toml.trim().is_empty() {
         more_deps.push_str(&format!("\n{}", extra_dependencies_toml));
     }
+    // mimalloc global allocator for every binary in the batch (all are executables, always native here).
+    let use_fast_alloc = fast_alloc_enabled();
+    if use_fast_alloc {
+        more_deps.push_str("\nmimalloc = \"0.1\"\n");
+    }
 
     let tish_ui_path = std::path::Path::new(&runtime_path)
         .parent()
@@ -346,6 +395,11 @@ pub(crate) fn build_many_via_cargo(
         } else {
             rust_code.clone()
         };
+        let rust_main = if use_fast_alloc {
+            inject_global_allocator(&rust_main)
+        } else {
+            rust_main
+        };
 
         fs::write(bin_dir.join("main.rs"), rust_main)
             .map_err(|e| format!("write main.rs for {}: {}", stem, e))?;

package/crates/tish_opt/src/lib.rs

@@ -23,6 +23,10 @@ fn optimize_statement(stmt: &Statement) -> Statement {
                 span: *span,
             }
         }
+        Statement::Multi { statements, span } => Statement::Multi {
+            statements: statements.iter().map(optimize_statement).collect(),
+            span: *span,
+        },
         Statement::VarDecl {
             name,
             name_span,
@@ -444,6 +448,10 @@ fn optimize_expr(expr: &Expr) -> Expr {
             operand: Box::new(optimize_expr(operand)),
             span: *span,
         },
+        Expr::Delete { target, span } => Expr::Delete {
+            target: Box::new(optimize_expr(target)),
+            span: *span,
+        },
         Expr::PostfixInc { .. }
         | Expr::PostfixDec { .. }
         | Expr::PrefixInc { .. }
@@ -554,19 +562,70 @@ fn literal_strict_eq(a: &Literal, b: &Literal) -> bool {
     }
 }
 
+/// JS `Number.prototype.toString` (radix 10). **Kept byte-for-byte in sync with
+/// `tishlang_core::js_number_to_string`** so a constant-folded `"" + n` here matches the
+/// runtime conversion there; `tish_opt` deliberately does not depend on `tish_core` (it is a
+/// lean AST pass), hence the small duplication of this fixed-spec algorithm. See that function
+/// for the full commentary.
+fn js_number_to_string(value: f64) -> String {
+    if value.is_nan() {
+        return "NaN".to_string();
+    }
+    if value == f64::INFINITY {
+        return "Infinity".to_string();
+    }
+    if value == f64::NEG_INFINITY {
+        return "-Infinity".to_string();
+    }
+    if value == 0.0 {
+        return if value.is_sign_negative() { "-0" } else { "0" }.to_string();
+    }
+    let negative = value < 0.0;
+    let sci = format!("{:e}", value.abs());
+    let (mantissa, exp_str) = sci
+        .split_once('e')
+        .expect("LowerExp formatting always contains 'e'");
+    let exp: i32 = exp_str
+        .parse()
+        .expect("LowerExp exponent is a valid integer");
+    let digits: String = mantissa.chars().filter(|&c| c != '.').collect();
+    let k = digits.len() as i32;
+    let point = exp + 1;
+
+    let mut out = String::new();
+    if negative {
+        out.push('-');
+    }
+    if k <= point && point <= 21 {
+        out.push_str(&digits);
+        out.push_str(&"0".repeat((point - k) as usize));
+    } else if 0 < point && point <= 21 {
+        out.push_str(&digits[..point as usize]);
+        out.push('.');
+        out.push_str(&digits[point as usize..]);
+    } else if -6 < point && point <= 0 {
+        out.push_str("0.");
+        out.push_str(&"0".repeat((-point) as usize));
+        out.push_str(&digits);
+    } else {
+        let e = point - 1;
+        out.push_str(&digits[..1]);
+        if k > 1 {
+            out.push('.');
+            out.push_str(&digits[1..]);
+        }
+        out.push('e');
+        out.push(if e >= 0 { '+' } else { '-' });
+        out.push_str(&e.abs().to_string());
+    }
+    out
+}
+
 fn literal_to_display_string(lit: &Literal) -> String {
     match lit {
-        Literal::Number(n) => {
-            if n.is_nan() {
-                "NaN".to_string()
-            } else if *n == f64::INFINITY {
-                "Infinity".to_string()
-            } else if *n == f64::NEG_INFINITY {
-                "-Infinity".to_string()
-            } else {
-                n.to_string()
-            }
-        }
+        // Must match the runtime exactly so constant-folded `"" + n` agrees with the
+        // unfolded path (see `js_number_to_string` below).
+        Literal::Number(n) => js_number_to_string(*n),
         Literal::String(s) => s.to_string(),
         Literal::Bool(b) => b.to_string(),
         Literal::Null => "null".to_string(),
@@ -708,6 +767,41 @@ fn try_algebraic_simplify(
     None
 }
 
+// JS ToInt32/ToUint32 for the constant folder. NaN/±Infinity → 0 (`f64 as i64` saturates, so a
+// folded `(1e308 * 10) | 0` would otherwise give -1 while the runtime gives 0). `tish_opt` has no
+// `tish_core` dep, so these mirror `tishlang_core::to_int32`/`to_uint32` (kept in sync, pure spec).
+#[inline]
+fn fold_to_int32(x: f64) -> i32 {
+    if x.is_finite() {
+        x as i64 as i32
+    } else {
+        0
+    }
+}
+#[inline]
+fn fold_to_uint32(x: f64) -> u32 {
+    if x.is_finite() {
+        x as i64 as u32
+    } else {
+        0
+    }
+}
+
+/// Constant-fold a relational comparison (`<` `<=` `>` `>=`). Two string literals
+/// compare lexicographically; otherwise the numeric coercions `ln`/`rn` are used.
+/// `pred` maps the `Ordering` to a bool; a NaN-involved numeric comparison has no
+/// ordering and is `false` — matching the VM/interp/native runtime exactly.
+fn fold_relational<F>(left: &Literal, right: &Literal, ln: f64, rn: f64, pred: F) -> bool
+where
+    F: FnOnce(std::cmp::Ordering) -> bool,
+{
+    let ord = match (left, right) {
+        (Literal::String(a), Literal::String(b)) => Some(a.as_ref().cmp(b.as_ref())),
+        _ => ln.partial_cmp(&rn),
+    };
+    ord.map(pred).unwrap_or(false)
+}
+
 fn try_fold_binop(left: &Literal, op: BinOp, right: &Literal) -> Option<Literal> {
     use BinOp::*;
     let ln = literal_as_number(left);
@@ -729,24 +823,33 @@ fn try_fold_binop(left: &Literal, op: BinOp, right: &Literal) -> Option<Literal>
         }
         Sub => Literal::Number(ln - rn),
         Mul => Literal::Number(ln * rn),
-        Div => Literal::Number(if rn == 0.0 { f64::NAN } else { ln / rn }),
-        Mod => Literal::Number(if rn == 0.0 { f64::NAN } else { ln % rn }),
+        // IEEE division/remainder, matching JS + the VM's `eval_binop` + interp + rust-AOT:
+        // `5/0` → Infinity, `-5/0` → -Infinity, `0/0` → NaN, `5%0` → NaN. The former
+        // `if rn == 0.0 { NaN }` folded `5/0` to NaN at compile time, diverging from every runtime
+        // path (which all produce Infinity) — a constant-fold-vs-runtime inconsistency.
+        Div => Literal::Number(ln / rn),
+        Mod => Literal::Number(ln % rn),
         Pow => Literal::Number(ln.powf(rn)),
         Eq => Literal::Bool(literal_strict_eq(left, right)),
         Ne => Literal::Bool(!literal_strict_eq(left, right)),
         StrictEq => Literal::Bool(literal_strict_eq(left, right)),
         StrictNe => Literal::Bool(!literal_strict_eq(left, right)),
-        Lt => Literal::Bool(ln < rn),
-        Le => Literal::Bool(ln <= rn),
-        Gt => Literal::Bool(ln > rn),
-        Ge => Literal::Bool(ln >= rn),
+        // Relational ops fold lexicographically when BOTH operands are string
+        // literals (JS semantics — must match the VM/interp/native runtime), else
+        // numerically. A NaN-involved numeric comparison is always false.
+        Lt => Literal::Bool(fold_relational(left, right, ln, rn, |o| o.is_lt())),
+        Le => Literal::Bool(fold_relational(left, right, ln, rn, |o| o.is_le())),
+        Gt => Literal::Bool(fold_relational(left, right, ln, rn, |o| o.is_gt())),
+        Ge => Literal::Bool(fold_relational(left, right, ln, rn, |o| o.is_ge())),
         And => Literal::Bool(literal_is_truthy(left) && literal_is_truthy(right)),
         Or => Literal::Bool(literal_is_truthy(left) || literal_is_truthy(right)),
-        BitAnd => Literal::Number((ln as i32 & rn as i32) as f64),
-        BitOr => Literal::Number((ln as i32 | rn as i32) as f64),
-        BitXor => Literal::Number((ln as i32 ^ rn as i32) as f64),
-        Shl => Literal::Number(((ln as i32) << (rn as i32)) as f64),
-        Shr => Literal::Number(((ln as i32) >> (rn as i32)) as f64),
+        // ToInt32/ToUint32 (modulo 2³², NaN/±Infinity → 0), matching the VM/interp exactly.
+        BitAnd => Literal::Number((fold_to_int32(ln) & fold_to_int32(rn)) as f64),
+        BitOr => Literal::Number((fold_to_int32(ln) | fold_to_int32(rn)) as f64),
+        BitXor => Literal::Number((fold_to_int32(ln) ^ fold_to_int32(rn)) as f64),
+        Shl => Literal::Number(fold_to_int32(ln).wrapping_shl(fold_to_uint32(rn)) as f64),
+        Shr => Literal::Number(fold_to_int32(ln).wrapping_shr(fold_to_uint32(rn)) as f64),
+        UShr => Literal::Number(fold_to_uint32(ln).wrapping_shr(fold_to_uint32(rn)) as f64),
         In => return None, // Requires object/array on right
     };
     Some(result)
@@ -936,7 +1039,7 @@ fn try_fold_unary(op: UnaryOp, operand: &Literal) -> Option<Literal> {
         Not => Literal::Bool(!literal_is_truthy(operand)),
         Neg => Literal::Number(-literal_as_number(operand)),
         Pos => Literal::Number(literal_as_number(operand)),
-        BitNot => Literal::Number(!(literal_as_number(operand) as i32) as f64),
+        BitNot => Literal::Number(!fold_to_int32(literal_as_number(operand)) as f64),
         Void => Literal::Null,
     };
     Some(result)

package/crates/tish_parser/src/lib.rs

@@ -6,9 +6,22 @@ use parser::Parser;
 
 use tishlang_ast::Program;
 use tishlang_lexer::Lexer;
+pub use tishlang_lexer::LexerOptions;
 
+/// Parse `source`, reading lexer options from the environment (e.g. `TISH_IGNORE_INDENT=1`
+/// to ignore indentation syntax). Every backend funnels through here, so the env toggle
+/// reaches run/build/dump-ast/fmt/lint/lsp uniformly.
 pub fn parse(source: &str) -> Result<Program, String> {
-    let lexer = Lexer::new(source);
+    parse_with_options(source, LexerOptions::from_env())
+}
+
+/// Parse with explicit lexer options, bypassing the environment.
+///
+/// With `LexerOptions { ignore_indent: true }`, indentation is treated as ordinary
+/// whitespace and blocks must be brace-delimited — useful for debugging how nested
+/// blocks transpile, since fully brace-delimited code parses identically either way.
+pub fn parse_with_options(source: &str, options: LexerOptions) -> Result<Program, String> {
+    let lexer = Lexer::with_options(source, options);
     let tokens: Result<Vec<_>, _> = lexer.collect();
     let tokens = tokens?;
     let mut parser = Parser::new(&tokens);
@@ -329,4 +342,45 @@ mod tests {
         assert!(matches!(stmts[1], Statement::VarDecl { .. }));
         assert!(matches!(stmts[2], Statement::If { .. }));
     }
+
+    #[test]
+    fn ignore_indent_parses_brace_blocks_identically() {
+        // Fully brace-delimited code: braces are authoritative, indentation is decoration.
+        // Ignoring indentation must therefore produce an identical AST.
+        let src = "fn f() {\n  let a = 1\n  if (a) {\n    let b = 2\n    g(b)\n  }\n}\n";
+        let normal = parse(src).expect("parse (indentation significant)");
+        let ignored = parse_with_options(src, LexerOptions { ignore_indent: true })
+            .expect("parse (indentation ignored)");
+        assert_eq!(
+            format!("{normal:#?}"),
+            format!("{ignored:#?}"),
+            "brace-delimited code must parse identically with indentation ignored"
+        );
+    }
+
+    #[test]
+    fn ignore_indent_drops_indentation_induced_block() {
+        // A leading-indented line makes the lexer open an indent level, so the parser wraps
+        // `a()` in a `Block` — the kind of stray, indentation-driven nesting that can give
+        // transpiled JS the wrong lexical scope. Ignoring indentation removes that wrapper.
+        let src = "  a()\nb()\n";
+
+        let normal = parse(src).expect("parse normal");
+        assert!(
+            matches!(normal.statements.first(), Some(Statement::Block { .. })),
+            "indentation should wrap a() in a Block, got: {:?}",
+            normal.statements
+        );
+
+        let ignored = parse_with_options(src, LexerOptions { ignore_indent: true })
+            .expect("parse ignored");
+        assert!(
+            ignored
+                .statements
+                .iter()
+                .all(|s| matches!(s, Statement::ExprStmt { .. })),
+            "with indentation ignored, both calls are flat expression statements, got: {:?}",
+            ignored.statements
+        );
+    }
 }