@tishlang/tish-format 3.3.3 → 3.6.0

package/crates/tish_compile/src/lib.rs

@@ -12,7 +12,7 @@ mod types;
 
 pub use schemes::{set_active as set_scheme_registry, SchemeRegistry};
 
-pub use check::{check_program, TypeDiagnostic};
+pub use check::{check_call_arity, check_program, TypeDiagnostic};
 
 /// The native typed-codegen optimizations — numeric param inference, struct/aggregate inference,
 /// native (monomorphic) free fns, native-vec params, recursive-struct arena lowering, fused/native
@@ -291,4 +291,36 @@ mod monomorphization_tests {
         assert!(rust.contains("value: f64"), "expected native f64 field; got:\n{}",
             rust.lines().filter(|l| l.contains("struct") || l.contains("value")).take(6).collect::<Vec<_>>().join("\n"));
     }
+
+    /// #614: a module-level binding demoted to boxed `Value` must NOT drag down a function-local
+    /// that merely shares its name. Both lowerings have to appear in one program — under the old
+    /// bare-name keying that was impossible, since one name got one verdict bundle-wide.
+    #[test]
+    fn module_demotion_does_not_box_a_same_named_local() {
+        let src = r#"
+let i = 0
+i = i + "x"
+function modern(n: number) {
+  let i = 0
+  let t = 0
+  while (i < n) { t = t + i * 2; i = i + 1 }
+  return t
+}
+console.log(i)
+console.log(modern(5))
+"#;
+        let rust = compile(&parse(src).unwrap()).unwrap();
+        // The module `i` really can hold a String (`i + "x"`), so it must stay boxed.
+        assert!(
+            rust.contains("let mut i = Value::Number(0_f64)"),
+            "module-level `i` must stay boxed; got:\n{}",
+            rust.lines().filter(|l| l.contains("let mut i")).collect::<Vec<_>>().join("\n")
+        );
+        // `modern`'s `i` is a different variable, provably numeric, and must lower natively.
+        assert!(
+            rust.contains("let mut i: f64 = 0_f64"),
+            "fn-local `i` must stay native f64; got:\n{}",
+            rust.lines().filter(|l| l.contains("let mut i")).collect::<Vec<_>>().join("\n")
+        );
+    }
 }

package/crates/tish_compile/src/resolve.rs

@@ -1231,6 +1231,29 @@ fn resolve_import_path(
             spec
         ));
     }
+    // #618: build-time package-variant selection. `package.json` may remap an import specifier to
+    // another module, which is tish's equivalent of a cargo feature swapping one implementation for
+    // another:
+    //
+    //     "tish": { "packageOverrides": { "./drop_tables": "./drop_tables_pocket" } }
+    //
+    // Applied to the SPECIFIER before any resolution, so it works for relative paths and package
+    // names alike, and the replacement is then resolved by the ordinary rules (relative to the
+    // importing file, as the original would have been). Matching is exact on the written
+    // specifier — no prefix or glob matching, so an override cannot silently capture an import the
+    // author did not mean to redirect.
+    //
+    // A remapped specifier is NOT re-checked against the override table: one substitution per
+    // import, so a table that maps A->B and B->A terminates instead of looping.
+    let overridden = {
+        let cfg = read_project_tish_config(project_root);
+        cfg.get("packageOverrides")
+            .and_then(|o| o.as_object())
+            .and_then(|o| o.get(spec))
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string())
+    };
+    let spec: &str = overridden.as_deref().unwrap_or(spec);
     if !spec.starts_with("./") && !spec.starts_with("../") {
         if let Some(path) = resolve_bare_spec(spec, from_dir, project_root) {
             return Ok(path);
@@ -1445,10 +1468,26 @@ fn collect_destructure_names(pattern: &DestructPattern, out: &mut HashSet<String
 
 /// Rename each module's non-exported top-level bindings whose name also occurs as a top-level
 /// name in another module, isolating module-private declarations (#97).
-fn isolate_private_top_level_bindings(modules: &mut [ResolvedModule]) {
+///
+/// #587: this ALSO covers colliding EXPORTED names in non-entry modules, returning
+/// `renamed symbol -> original export name` per module so the export table can still be keyed by the
+/// name importers ask for. The original carve-out ("exported names stay stable so imports keep
+/// resolving") was stricter than necessary: `module_exports` is already an INDIRECTION from export
+/// name to source symbol, so the symbol is free to move as long as the key does not.
+///
+/// Leaving exported collisions alone was not merely a missed optimisation — it silently produced a
+/// wrong program. Two modules exporting `greet`, flattened into one scope, emit two
+/// `function greet` declarations; JS function declarations HOIST, so the second overwrote the first
+/// before `const _greet = greet` ran, and a barrel that re-wrapped its own import recursed until the
+/// stack blew.
+///
+/// The ENTRY module is deliberately excluded: its exports are the bundle's public surface, so
+/// renaming them would change the API the caller sees.
+fn isolate_private_top_level_bindings(modules: &mut [ResolvedModule]) -> Vec<HashMap<String, String>> {
     let n = modules.len();
+    let mut export_renames: Vec<HashMap<String, String>> = vec![HashMap::new(); n];
     if n < 2 {
-        return; // a single module cannot collide with another
+        return export_renames; // a single module cannot collide with another
     }
     let mut decls: Vec<HashSet<String>> = vec![HashSet::new(); n];
     let mut exported: Vec<HashSet<String>> = vec![HashSet::new(); n];
@@ -1471,13 +1510,35 @@ fn isolate_private_top_level_bindings(modules: &mut [ResolvedModule]) {
             *count.entry(name.as_str()).or_insert(0) += 1;
         }
     }
+    // #587: for EXPORTED names the question is different, and `occupancy` answers the wrong one.
+    // It counts import bindings, so a dep's exported `greet` looks like it collides with the
+    // importer's binding of that same `greet` — but those are one thing, not two, and renaming on
+    // that basis breaks nothing yet churns every ordinary import. A real collision is another module
+    // DECLARING the name, so exported renames key off declarations only.
+    let mut decl_count: HashMap<&str, usize> = HashMap::new();
+    for d in &decls {
+        for name in d {
+            *decl_count.entry(name.as_str()).or_insert(0) += 1;
+        }
+    }
     for (i, m) in modules.iter_mut().enumerate() {
+        let is_entry = i + 1 == n; // the entry module is last — its exports are the public surface
         let mut renames: HashMap<String, Arc<str>> = HashMap::new();
         for name in &decls[i] {
-            if exported[i].contains(name) {
-                continue; // exported names stay stable so imports keep resolving
+            if count.get(name.as_str()).copied().unwrap_or(0) <= 1 {
+                continue; // no collision — leave it exactly as it is (zero blast radius)
             }
-            if count.get(name.as_str()).copied().unwrap_or(0) > 1 {
+            if exported[i].contains(name) {
+                // #587: an exported collision in a NON-ENTRY module is renamed too, and the new
+                // symbol is recorded so `module_exports` can still answer to the original name.
+                // Gated on DECLARATION count — see the note above.
+                if is_entry || decl_count.get(name.as_str()).copied().unwrap_or(0) <= 1 {
+                    continue;
+                }
+                let renamed = format!("{name}__m{i}");
+                export_renames[i].insert(renamed.clone(), name.clone());
+                renames.insert(name.clone(), Arc::from(renamed));
+            } else {
                 renames.insert(name.clone(), Arc::from(format!("{name}__m{i}")));
             }
         }
@@ -1491,6 +1552,7 @@ fn isolate_private_top_level_bindings(modules: &mut [ResolvedModule]) {
             rewrite_stmt_scope(stmt, &mut active, true);
         }
     }
+    export_renames
 }
 
 /// Apply the rename for a *declared* name. At module top level the binding is the canonical
@@ -1896,7 +1958,7 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
     }
 
     // #97: isolate module-private top-level bindings before they are flattened together.
-    isolate_private_top_level_bindings(&mut modules);
+    let export_renames = isolate_private_top_level_bindings(&mut modules);
 
     let path_to_idx: HashMap<PathBuf, usize> = modules
         .iter()
@@ -1916,7 +1978,14 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                             }
                             _ => continue,
                         };
-                        module_exports[idx].insert(name.clone(), name);
+                        // #587: if this symbol was renamed for an exported collision, the export
+                        // table must still answer to the name importers ask for — key by the
+                        // ORIGINAL, point at the renamed symbol.
+                        let key = export_renames[idx]
+                            .get(&name)
+                            .cloned()
+                            .unwrap_or_else(|| name.clone());
+                        module_exports[idx].insert(key, name);
                     }
                     ExportDeclaration::Default(_) => {
                         let default_name = format!("__default_{}", idx);

package/crates/tish_compile/src/types.rs

@@ -327,6 +327,27 @@ impl RustType {
                 | BinOp::StrictNe => Some(RustType::Bool),
                 _ => None,
             }
+        } else if (lhs == &RustType::Fixed && rhs == &RustType::F64)
+            || (lhs == &RustType::F64 && rhs == &RustType::Fixed)
+        {
+            // #606: a MIXED `fixed`/`f64` operand pair. Previously this fell through to `None`, so
+            // the whole expression dropped to the boxed `ops::*` path — and on an FPU-less
+            // ARM7TDMI that path also routes through SOFT-FLOAT f64, which is the expensive part.
+            //
+            // The f64 side is lifted to `Fixed` at the operator, with the SAME truncating semantics
+            // the literal fold already applies (`Fixed::from_raw((x * 256.0) as i32)`), so a mixed
+            // expression now agrees with the equivalent all-literal one instead of disagreeing with
+            // it. `%`/`**`/bitwise stay boxed, exactly as they do for `Fixed × Fixed`.
+            match op {
+                BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div => Some(RustType::Fixed),
+                BinOp::Lt
+                | BinOp::Le
+                | BinOp::Gt
+                | BinOp::Ge
+                | BinOp::StrictEq
+                | BinOp::StrictNe => Some(RustType::Bool),
+                _ => None,
+            }
         } else if lhs == &RustType::Fixed && rhs == &RustType::Fixed {
             // agb `Num<i32,8>` overloads `+ - * /` (Mul/Div apply the Q24.8 shift
             // correction) and `PartialOrd`/`PartialEq`, so these lower to native
@@ -512,8 +533,21 @@ impl RustType {
                 "match &{} {{ Value::String(s) => s.to_string(), _ => panic!(\"expected string\") }}",
                 value_expr
             ),
+            // #610: A NUMBER REACHING A BOOL BOUNDARY MUST NOT SHIP A PANIC. This arm accepted only
+            // `Value::Bool`, so passing `1` where a typed extern — or any bool-typed boundary —
+            // declares `bool` compiled clean, emitted no coercion, and panicked on the first call.
+            // The failure is latent until that exact line runs, which is how tish-gba's space-goo
+            // shipped it.
+            //
+            // Numbers coerce as `n != 0`. This does NOT reintroduce loose equality: `bool === 1` is
+            // still false, because that is a question about the COMPARISON operator. This is a
+            // boundary CONVERSION — the signature has already said `bool`, the way an `as` cast
+            // would — and a total conversion there beats a guaranteed abort.
+            //
+            // Anything genuinely unconvertible still panics, so a string or object reaching a bool
+            // parameter stays exactly as loud as before.
             RustType::Bool => format!(
-                "match &{} {{ Value::Bool(b) => *b, _ => panic!(\"expected boolean\") }}",
+                "match &{} {{ Value::Bool(b) => *b, Value::Number(n) => *n != 0.0, _ => panic!(\"expected boolean\") }}",
                 value_expr
             ),
             RustType::Unit => "()".to_string(),

package/crates/tish_compile/tests/call_arity_641.rs

@@ -0,0 +1,104 @@
+//! #641 — call arity. A call with too few arguments used to compile, bind the missing parameter to
+//! `Value::Null`, and then either panic at runtime (boxed callee, typed params), fail in rustc
+//! (direct native callee), or silently yield null/NaN (interpreter) — depending on which lowering
+//! the CALLEE happened to get. These pin the rule and, just as importantly, the non-rule: omitting
+//! an argument bound to an UNTYPED parameter stays legal, because shipping packages rely on it.
+
+use tishlang_compile::check_call_arity;
+use tishlang_parser::parse;
+
+fn diags(src: &str) -> Vec<String> {
+    let p = parse(src).expect("parse");
+    check_call_arity(&p).into_iter().map(|d| d.message).collect()
+}
+
+#[test]
+fn omitting_a_typed_parameter_is_an_error() {
+    let d = diags(
+        r#"
+function paintTyped(slot: i32, rv: i32): i32 { return slot + rv }
+paintTyped(1)
+"#,
+    );
+    assert_eq!(d.len(), 1, "expected exactly one diagnostic, got {:?}", d);
+    assert!(d[0].contains("paintTyped"), "names the callee: {}", d[0]);
+    assert!(d[0].contains("needs 2"), "states the requirement: {}", d[0]);
+}
+
+#[test]
+fn omitting_an_untyped_parameter_is_allowed() {
+    // The established idiom: `packages/shop.tish` has six of these, `packages/ui.tish` one.
+    // Enforcing arity here would break shipping code that is behaving exactly as intended.
+    let d = diags(
+        r#"
+function renderTab(defer, stream) { return 1 }
+renderTab()
+renderTab(1)
+renderTab(1, 1)
+"#,
+    );
+    assert!(d.is_empty(), "untyped params must stay optional, got {:?}", d);
+}
+
+#[test]
+fn a_defaulted_parameter_imposes_no_minimum() {
+    // The default is what fills the slot, so nothing arrives as null.
+    let d = diags(
+        r#"
+function f(a: i32, b: i32 = 7): i32 { return a + b }
+f(1)
+"#,
+    );
+    assert!(d.is_empty(), "a default supplies the argument, got {:?}", d);
+}
+
+#[test]
+fn a_typed_parameter_after_untyped_ones_still_forces_its_position() {
+    // A call cannot skip positions to reach `c`, so the minimum is 3 even though 0 and 1 are
+    // untyped — the minimum is one past the LAST typed parameter, not a count of typed ones.
+    let d = diags(
+        r#"
+function g(a, b, c: i32): i32 { return c }
+g(1, 2)
+"#,
+    );
+    assert_eq!(d.len(), 1, "expected one diagnostic, got {:?}", d);
+    assert!(d[0].contains("needs 3"), "minimum is positional: {}", d[0]);
+}
+
+#[test]
+fn a_spread_argument_is_not_second_guessed() {
+    // The count is unknowable at compile time; saying nothing beats guessing wrong.
+    let d = diags(
+        r#"
+function h(a: i32, b: i32): i32 { return a + b }
+let xs = [1, 2]
+h(...xs)
+"#,
+    );
+    assert!(d.is_empty(), "spread must not be flagged, got {:?}", d);
+}
+
+#[test]
+fn a_nested_call_is_still_seen() {
+    // The reported shape. `for_each_stmt_expr` hands out only a statement's ROOT expression, so
+    // without full sub-expression walking this exact case — the one in the issue — is missed.
+    let d = diags(
+        r#"
+function paintTyped(slot: i32, rv: i32): i32 { return slot + rv }
+console.log("v = " + paintTyped(1))
+"#,
+    );
+    assert_eq!(d.len(), 1, "nested call must be checked, got {:?}", d);
+}
+
+#[test]
+fn a_correct_call_is_silent() {
+    let d = diags(
+        r#"
+function paintTyped(slot: i32, rv: i32): i32 { return slot + rv }
+paintTyped(1, 2)
+"#,
+    );
+    assert!(d.is_empty(), "correct arity must not warn, got {:?}", d);
+}

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "3.3.3"
+version = "3.6.0"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "3.3.3",
+  "version": "3.6.0",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {