@tishlang/tish 2.2.5 → 2.8.0

package/crates/tish_compile/src/infer.rs

@@ -52,15 +52,15 @@ impl InferCtx {
 }
 
 fn is_number(ann: &TypeAnnotation) -> bool {
-    matches!(ann, TypeAnnotation::Simple(s) if s.as_ref() == "number")
+    matches!(ann, TypeAnnotation::Simple(s, _) if s.as_ref() == "number")
 }
 
 fn is_string(ann: &TypeAnnotation) -> bool {
-    matches!(ann, TypeAnnotation::Simple(s) if s.as_ref() == "string")
+    matches!(ann, TypeAnnotation::Simple(s, _) if s.as_ref() == "string")
 }
 
 fn is_bool(ann: &TypeAnnotation) -> bool {
-    matches!(ann, TypeAnnotation::Simple(s) if s.as_ref() == "boolean")
+    matches!(ann, TypeAnnotation::Simple(s, _) if s.as_ref() == "boolean")
 }
 
 /// Element type of an array literal of uniform native scalars (number/string/boolean), for
@@ -91,15 +91,15 @@ fn infer_array_elem(elements: &[tishlang_ast::ArrayElement], ctx: &InferCtx) ->
 }
 
 fn number_ann() -> TypeAnnotation {
-    TypeAnnotation::Simple("number".into())
+    TypeAnnotation::Simple("number".into(), tishlang_ast::Span::default())
 }
 
 fn string_ann() -> TypeAnnotation {
-    TypeAnnotation::Simple("string".into())
+    TypeAnnotation::Simple("string".into(), tishlang_ast::Span::default())
 }
 
 fn bool_ann() -> TypeAnnotation {
-    TypeAnnotation::Simple("boolean".into())
+    TypeAnnotation::Simple("boolean".into(), tishlang_ast::Span::default())
 }
 
 /// Infer the `TypeAnnotation` for an expression, if unambiguous.
@@ -237,7 +237,7 @@ fn pi_stmt(s: Statement) -> Statement {
                         && tp.default.is_none()
                         && nus_stmt(&body, tp.name.as_ref(), &nums)
                     {
-                        tp.type_ann = Some(TypeAnnotation::Simple(std::sync::Arc::from("number")));
+                        tp.type_ann = Some(TypeAnnotation::Simple(std::sync::Arc::from("number"), tishlang_ast::Span::default()));
                     }
                     FunParam::Simple(tp)
                 }
@@ -558,7 +558,7 @@ pub(crate) fn pi_mentions(e: &Expr, name: &str) -> bool {
             }
         }),
         Object { props, .. } => props.iter().any(|p| match p {
-            tishlang_ast::ObjectProp::KeyValue(_, v) => pi_mentions(v, name),
+            tishlang_ast::ObjectProp::KeyValue(_, v, _) => pi_mentions(v, name),
             tishlang_ast::ObjectProp::Spread(x) => pi_mentions(x, name),
         }),
         TemplateLiteral { exprs, .. } => exprs.iter().any(|x| pi_mentions(x, name)),
@@ -612,7 +612,7 @@ impl StructRegistry {
 
 fn type_canon(t: &TypeAnnotation) -> String {
     match t {
-        TypeAnnotation::Simple(s) => s.to_string(),
+        TypeAnnotation::Simple(s, _) => s.to_string(),
         TypeAnnotation::Object(fields) => format!(
             "{{{}}}",
             fields
@@ -634,10 +634,10 @@ fn infer_object_shape(
     let mut fields = Vec::with_capacity(props.len());
     for p in props {
         match p {
-            tishlang_ast::ObjectProp::KeyValue(k, v) => {
+            tishlang_ast::ObjectProp::KeyValue(k, v, _) => {
                 let ty = infer_expr_type(v, ctx)?;
                 // Only primitive field types in this conservative version.
-                if !matches!(&ty, TypeAnnotation::Simple(s)
+                if !matches!(&ty, TypeAnnotation::Simple(s, _)
                     if matches!(s.as_ref(), "number" | "string" | "boolean"))
                 {
                     return None;
@@ -776,12 +776,12 @@ fn si_block(stmts: Vec<Statement>, reg: &mut StructRegistry, ctx: &mut InferCtx)
                 // Sound: every later use in this block must be a literal-key read.
                 if uses_are_struct_safe(name.as_ref(), &keys, &stmts[i + 1..]) {
                     let alias = reg.intern(&fields);
-                    ctx.define(name.as_ref(), TypeAnnotation::Simple(alias.as_str().into()));
+                    ctx.define(name.as_ref(), TypeAnnotation::Simple(alias.as_str().into(), tishlang_ast::Span::default()));
                     out.push(Statement::VarDecl {
                         name: name.clone(),
                         name_span: *name_span,
                         mutable: *mutable,
-                        type_ann: Some(TypeAnnotation::Simple(alias.as_str().into())),
+                        type_ann: Some(TypeAnnotation::Simple(alias.as_str().into(), tishlang_ast::Span::default())),
                         init: stmt_init_clone(stmt),
                         span: *span,
                     });
@@ -1303,7 +1303,7 @@ fn arr_expr_safe(e: &Expr, name: &str) -> bool {
             }
         }),
         Object { props, .. } => props.iter().all(|p| match p {
-            tishlang_ast::ObjectProp::KeyValue(_, v) => arr_expr_safe(v, name),
+            tishlang_ast::ObjectProp::KeyValue(_, v, _) => arr_expr_safe(v, name),
             tishlang_ast::ObjectProp::Spread(v) => arr_expr_safe(v, name),
         }),
         // Anything else that mentions `name`: be safe, bail.
@@ -1423,7 +1423,7 @@ fn expr_name_safe(e: &Expr, name: &str, keys: &std::collections::HashSet<&str>)
             }
         }),
         Object { props, .. } => props.iter().all(|p| match p {
-            tishlang_ast::ObjectProp::KeyValue(_, v) => expr_name_safe(v, name, keys),
+            tishlang_ast::ObjectProp::KeyValue(_, v, _) => expr_name_safe(v, name, keys),
             tishlang_ast::ObjectProp::Spread(e) => expr_name_safe(e, name, keys),
         }),
         TemplateLiteral { exprs, .. } => exprs.iter().all(|e| expr_name_safe(e, name, keys)),
@@ -1642,7 +1642,7 @@ mod param_infer_tests {
                         if let FunParam::Simple(tp) = p {
                             if tp.name.as_ref() == param {
                                 return tp.type_ann.as_ref().map(|a| match a {
-                                    TypeAnnotation::Simple(s) => s.to_string(),
+                                    TypeAnnotation::Simple(s, _) => s.to_string(),
                                     _ => "<complex>".to_string(),
                                 });
                             }

package/crates/tish_compile/src/lib.rs

@@ -186,6 +186,44 @@ fn factory() {
             "expected outerVar to be inferred as f64 (Copy, no clone needed)"
         );
     }
+
+    /// i32-loop-var lowering: an FNV-style integer/bitwise hash accumulator declared before a `for`
+    /// and reassigned only by `>>> 0`/bitwise ops lives in an `i32` register across the loop — no
+    /// per-op `to_int32(h)`↔`f64` round-trip — with a single `f64` excursion for the `h * C`
+    /// multiply (which exceeds 2^53, so it must round in f64 before `>>> 0`, exactly as V8 does).
+    #[test]
+    fn fnv_accumulator_lowers_to_i32_register() {
+        let src = r#"
+let h = 2166136261
+for (let i = 0; i < 100; i++) {
+  h = h ^ (i & 255)
+  h = (h * 16777619) >>> 0
+  h = ((h << 13) | (h >>> 19)) >>> 0
+}
+let check = h >>> 0
+console.log(check)
+"#;
+        let rust = compile(&parse(src).unwrap()).unwrap();
+        // The accumulator is an i32 register, initialized via the u32 reinterpretation so the
+        // > i32::MAX seed keeps its JS ToInt32 bit-pattern.
+        assert!(
+            rust.contains("let mut h: i32 = (2166136261u32) as i32;"),
+            "expected `h` to be an i32 register seeded via u32 reinterpretation; got:\n{}",
+            rust.lines().filter(|l| l.contains("h")).take(8).collect::<Vec<_>>().join("\n")
+        );
+        // The per-iteration `to_int32(h)` round-trips are gone: `h` is read straight from the
+        // register inside the bitwise chain (no `to_int32(h)` substring referencing the accumulator).
+        assert!(
+            !rust.contains("to_int32(h)"),
+            "expected NO per-op `to_int32(h)` round-trip on the i32 accumulator"
+        );
+        // The only f64 excursion is the multiply, lowered as an unchecked truncation of the
+        // provably-finite product (`h as f64 * 16777619`).
+        assert!(
+            rust.contains(".to_int_unchecked::<i64>()") && rust.contains("16777619"),
+            "expected the `h * 16777619` excursion to lower to an unchecked f64 truncation"
+        );
+    }
 }
 
 #[cfg(test)]

package/crates/tish_compile/src/resolve.rs

@@ -173,7 +173,7 @@ pub fn program_uses_document(program: &Program) -> bool {
                 ArrayElement::Expr(e) | ArrayElement::Spread(e) => expr_uses_document(e),
             }),
             Expr::Object { props, .. } => props.iter().any(|p| match p {
-                ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => expr_uses_document(e),
+                ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => expr_uses_document(e),
             }),
             Expr::Assign { value, .. }
             | Expr::CompoundAssign { value, .. }
@@ -1601,7 +1601,7 @@ fn rewrite_expr_scope(expr: &mut Expr, active: &HashMap<String, Arc<str>>) {
         Expr::Object { props, .. } => {
             for p in props {
                 match p {
-                    ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => {
+                    ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => {
                         rewrite_expr_scope(e, active) // key is a property name; value recurses
                     }
                 }
@@ -1819,6 +1819,7 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                                             name: Arc::from(v.clone()),
                                             span: *span,
                                         },
+                                        *name_span,
                                     ));
                                 }
                                 merge_push(

package/crates/tish_compile/src/types.rs

@@ -13,6 +13,12 @@ pub enum RustType {
     Value,
     /// f64 (for number)
     F64,
+    /// i32 — a `number` local PROVEN to always hold an integer reinterpretable as a JS ToInt32
+    /// bit-pattern, kept in an integer register across a bitwise/hash hot loop (bun/JSC-style)
+    /// instead of round-tripping `f64`↔`i32` on every op. The value is the signed int32
+    /// (= JS `ToInt32`) view; `>>> 0` results are uint32 reinterpreted into this i32. Only the
+    /// codegen's i32-loop-var lowering produces this type — never `from_annotation`.
+    I32,
     /// String (for string)
     String,
     /// bool (for boolean)
@@ -62,7 +68,7 @@ impl RustType {
         aliases: &HashMap<String, RustType>,
     ) -> Self {
         match ann {
-            TypeAnnotation::Simple(name) => match name.as_ref() {
+            TypeAnnotation::Simple(name, _) => match name.as_ref() {
                 "number" => RustType::F64,
                 "string" => RustType::String,
                 "boolean" | "bool" => RustType::Bool,
@@ -111,10 +117,10 @@ impl RustType {
                 if types.len() == 2 {
                     let has_null = types
                         .iter()
-                        .any(|t| matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"));
+                        .any(|t| matches!(t, TypeAnnotation::Simple(s, _) if s.as_ref() == "null"));
                     if has_null {
                         let non_null = types.iter().find(
-                            |t| !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"),
+                            |t| !matches!(t, TypeAnnotation::Simple(s, _) if s.as_ref() == "null"),
                         );
                         if let Some(inner) = non_null {
                             return RustType::Option(Box::new(Self::from_annotation_with_aliases(
@@ -222,6 +228,7 @@ impl RustType {
         match self {
             RustType::Value => "Value".to_string(),
             RustType::F64 => "f64".to_string(),
+            RustType::I32 => "i32".to_string(),
             RustType::String => "String".to_string(),
             RustType::Bool => "bool".to_string(),
             RustType::Unit => "()".to_string(),
@@ -250,6 +257,7 @@ impl RustType {
         match self {
             RustType::Value => "Value::Null".to_string(),
             RustType::F64 => "0.0".to_string(),
+            RustType::I32 => "0i32".to_string(),
             RustType::String => "String::new()".to_string(),
             RustType::Bool => "false".to_string(),
             RustType::Unit => "()".to_string(),
@@ -306,6 +314,12 @@ impl RustType {
                 "match &{} {{ Value::Number(n) => *n, _ => panic!(\"expected number\") }}",
                 value_expr
             ),
+            // A `Value::Number` narrowed to its JS ToInt32 bit-pattern (NaN/±Inf → 0, exactly as
+            // the bitwise/shift path coerces). Only reached for an `I32`-typed binding boundary.
+            RustType::I32 => format!(
+                "match &{} {{ Value::Number(n) => tishlang_runtime::to_int32(*n), _ => panic!(\"expected number\") }}",
+                value_expr
+            ),
             RustType::String => format!(
                 "match &{} {{ Value::String(s) => s.to_string(), _ => panic!(\"expected string\") }}",
                 value_expr
@@ -363,6 +377,9 @@ impl RustType {
             }
             RustType::Value => native_expr.to_string(),
             RustType::F64 => format!("Value::Number({})", native_expr),
+            // The signed int32 view boxes as a JS Number (every i32 is exactly representable in
+            // f64). The uint32 `>>> 0` reinterpretation is applied at the boxing site, not here.
+            RustType::I32 => format!("Value::Number(({}) as f64)", native_expr),
             RustType::String => format!("Value::String({}.clone().into())", native_expr),
             RustType::Bool => format!("Value::Bool({})", native_expr),
             RustType::Unit => "Value::Null".to_string(),
@@ -532,22 +549,22 @@ mod tests {
     #[test]
     fn test_simple_types() {
         assert_eq!(
-            RustType::from_annotation(&TypeAnnotation::Simple("number".into())),
+            RustType::from_annotation(&TypeAnnotation::Simple("number".into(), tishlang_ast::Span::default())),
             RustType::F64
         );
         assert_eq!(
-            RustType::from_annotation(&TypeAnnotation::Simple("string".into())),
+            RustType::from_annotation(&TypeAnnotation::Simple("string".into(), tishlang_ast::Span::default())),
             RustType::String
         );
         assert_eq!(
-            RustType::from_annotation(&TypeAnnotation::Simple("boolean".into())),
+            RustType::from_annotation(&TypeAnnotation::Simple("boolean".into(), tishlang_ast::Span::default())),
             RustType::Bool
         );
     }
 
     #[test]
     fn test_array_type() {
-        let arr_type = TypeAnnotation::Array(Box::new(TypeAnnotation::Simple("number".into())));
+        let arr_type = TypeAnnotation::Array(Box::new(TypeAnnotation::Simple("number".into(), tishlang_ast::Span::default())));
         assert_eq!(
             RustType::from_annotation(&arr_type),
             RustType::Vec(Box::new(RustType::F64))
@@ -557,8 +574,8 @@ mod tests {
     #[test]
     fn test_nullable_type() {
         let nullable = TypeAnnotation::Union(vec![
-            TypeAnnotation::Simple("string".into()),
-            TypeAnnotation::Simple("null".into()),
+            TypeAnnotation::Simple("string".into(), tishlang_ast::Span::default()),
+            TypeAnnotation::Simple("null".into(), tishlang_ast::Span::default()),
         ]);
         assert_eq!(
             RustType::from_annotation(&nullable),

package/crates/tish_compile_js/src/codegen.rs

@@ -487,9 +487,29 @@ impl Codegen {
         }
     }
 
+    /// Is `expr` the `null` literal? Used to lower `x === null` / `x !== null` to JS `== null` /
+    /// `!= null` so the check catches `undefined` too (tish treats a missing/undefined value as
+    /// null on every other backend) — see the StrictEq/StrictNe arms below.
+    fn is_null_literal(expr: &Expr) -> bool {
+        matches!(
+            expr,
+            Expr::Literal {
+                value: Literal::Null,
+                ..
+            }
+        )
+    }
+
     fn emit_expr(&mut self, expr: &Expr) -> Result<String, CompileError> {
         Ok(match expr {
             Expr::Literal { value, .. } => match value {
+                // Rust's `{}` prints non-finite f64 as `inf` / `-inf` / `NaN`; only `NaN` is valid JS.
+                // Emit the JS spellings so a folded `1/0` / `-1/0` doesn't become an undefined `inf`
+                // identifier in the output.
+                Literal::Number(n) if n.is_nan() => "NaN".to_string(),
+                Literal::Number(n) if n.is_infinite() => {
+                    if *n < 0.0 { "-Infinity".to_string() } else { "Infinity".to_string() }
+                }
                 Literal::Number(n) => format!("{}", n),
                 Literal::String(s) => format!("{:?}", s.as_ref()),
                 Literal::Bool(b) => format!("{}", b),
@@ -510,8 +530,26 @@ impl Codegen {
                     BinOp::Pow => "**",
                     BinOp::Eq => "==",
                     BinOp::Ne => "!=",
-                    BinOp::StrictEq => "===",
-                    BinOp::StrictNe => "!==",
+                    // tish has no `undefined`: a missing/absent value reads back as `null`, so
+                    // `x === null` means "is nullish" — exactly how interp/vm/native behave (a
+                    // missing property is null there). In the JS runtime a missing property is
+                    // `undefined`, so lower `=== null` / `!== null` to loose `== null` / `!= null`,
+                    // which match BOTH null and undefined — keeping `=== null` mean the same thing on
+                    // every target. Strict equality between non-null operands is unaffected.
+                    BinOp::StrictEq => {
+                        if Self::is_null_literal(left) || Self::is_null_literal(right) {
+                            "=="
+                        } else {
+                            "==="
+                        }
+                    }
+                    BinOp::StrictNe => {
+                        if Self::is_null_literal(left) || Self::is_null_literal(right) {
+                            "!="
+                        } else {
+                            "!=="
+                        }
+                    }
                     BinOp::Lt => "<",
                     BinOp::Le => "<=",
                     BinOp::Gt => ">",
@@ -563,6 +601,15 @@ impl Codegen {
                 ..
             } => {
                 let obj = self.emit_expr(object)?;
+                // `255.toString()` is a JS syntax error — the lexer reads `255.` as a float and
+                // then chokes on the method name. Parenthesize a numeric-literal object so member
+                // access / method calls stay valid: `(255).toString()`. (Folded constants reach
+                // codegen as number literals too, so this covers e.g. `(100 * 2).toString()`.)
+                let obj = if matches!(&**object, Expr::Literal { value: Literal::Number(_), .. }) {
+                    format!("({})", obj)
+                } else {
+                    obj
+                };
                 let expr = match prop {
                     MemberProp::Name { name, .. } => {
                         if name.parse::<u32>().is_ok()
@@ -629,7 +676,7 @@ impl Codegen {
                 let parts: Result<Vec<_>, _> = props
                     .iter()
                     .map(|p| match p {
-                        ObjectProp::KeyValue(k, v) => {
+                        ObjectProp::KeyValue(k, v, _) => {
                             let key = k.as_ref();
                             let val = self.emit_expr(v)?;
                             Ok(if key.chars().all(|c| c.is_alphanumeric() || c == '_') {
@@ -650,7 +697,11 @@ impl Codegen {
             }
             Expr::TypeOf { operand, .. } => {
                 let o = self.emit_expr(operand)?;
-                format!("(typeof {})", o)
+                // tish `typeof null` is "null" (interp/vm/native all agree — null is a first-class
+                // type, not JS's `typeof null === "object"` wart). tish has no `undefined`, so any
+                // nullish operand (incl. a JS-runtime `undefined`) maps to "null". Evaluate the
+                // operand once via the arrow arg so side effects don't run twice.
+                format!("((__v) => __v == null ? \"null\" : typeof __v)({})", o)
             }
             Expr::Delete { target, .. } => {
                 // Emit the raw property *reference*, not a value: `emit_expr` wraps Index /

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -411,4 +411,48 @@ fn factory() {
             );
         }
     }
+
+    // tish `=== null` / `!== null` lower to JS `== null` / `!= null` so the nullish check catches the
+    // JS-runtime `undefined` (missing props / holes) too — matching interp/vm/native, which read a
+    // missing property back as null. Strict equality between non-null operands stays strict.
+    #[test]
+    fn strict_eq_null_lowers_to_loose_null() {
+        let program = parse("let x = 1\nconsole.log(x === null)\nconsole.log(x !== null)\n").unwrap();
+        let js = crate::compile(&program, false).unwrap();
+        assert!(!js.contains("=== null"), "`=== null` must lower to `== null`:\n{js}");
+        assert!(!js.contains("!== null"), "`!== null` must lower to `!= null`:\n{js}");
+        assert!(
+            js.contains("== null") && js.contains("!= null"),
+            "expected loose null checks:\n{js}"
+        );
+    }
+
+    #[test]
+    fn strict_eq_between_non_null_operands_stays_strict() {
+        let program = parse("let a = 1\nlet b = 2\nconsole.log(a === b)\nconsole.log(a !== b)\n").unwrap();
+        let js = crate::compile(&program, false).unwrap();
+        assert!(js.contains("==="), "non-null `===` must stay strict:\n{js}");
+        assert!(js.contains("!=="), "non-null `!==` must stay strict:\n{js}");
+    }
+
+    // `typeof null` is "null" in tish (interp/vm/native agree — null is a first-class type), not JS's
+    // `typeof null === "object"` wart. The JS backend must map a nullish operand to "null".
+    #[test]
+    fn typeof_null_emits_null_not_object() {
+        let program = parse("console.log(typeof null)\n").unwrap();
+        let js = crate::compile(&program, false).unwrap();
+        assert!(!js.contains("(typeof null)"), "must not emit raw `typeof null`:\n{js}");
+        assert!(js.contains("\"null\""), "typeof of a nullish value must yield \"null\":\n{js}");
+    }
+
+    // 1/0 and -1/0 fold to Infinity / -Infinity; emit the JS spellings, not Rust's `inf` / `-inf`
+    // (which would be undefined identifiers in the output).
+    #[test]
+    fn non_finite_number_literals_use_js_spellings() {
+        let pos = crate::compile(&parse("console.log(1 / 0)\n").unwrap(), true).unwrap();
+        assert!(pos.contains("Infinity"), "1/0 must emit Infinity:\n{pos}");
+        assert!(!pos.contains("inf"), "must not emit Rust's lowercase `inf`:\n{pos}");
+        let neg = crate::compile(&parse("console.log(-1 / 0)\n").unwrap(), true).unwrap();
+        assert!(neg.contains("-Infinity"), "-1/0 must emit -Infinity:\n{neg}");
+    }
 }

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -394,6 +394,7 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                             name: Arc::from(v.clone()),
                                             span: *span,
                                         },
+                                        *name_span,
                                     ));
                                 }
                                 statements.push(Statement::VarDecl {

package/crates/tish_core/Cargo.toml

@@ -23,6 +23,8 @@ ahash = "0.8.11"
 arcstr = "1"
 smallvec = "1"
 indexmap = "2"
+# Fast integer→decimal for the JSON.stringify number fast-path (already in the workspace lock).
+itoa = "1"
 fancy-regex = { version = "0.17.0", optional = true }
 # Only under `send-values` (the Arc<Mutex> path): parking_lot's uncontended lock is a
 # single atomic with no pthread syscall — profiled as a top cost on object/array access.