@tishlang/tish 1.13.2 → 2.0.0

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
+        );
+    }
 }