@tishlang/tish-format 1.0.13 → 2.0.2

package/crates/tish_compile/src/lib.rs

@@ -2,11 +2,14 @@
 //!
 //! Emits Rust source that links to tishlang_runtime.
 
+mod check;
 mod codegen;
 mod infer;
 mod resolve;
 mod types;
 
+pub use check::{check_program, TypeDiagnostic};
+
 /// How generated Rust is linked (desktop binary vs embedded iOS staticlib).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum NativeEmitMode {
@@ -26,7 +29,8 @@ pub use resolve::{
     cargo_export_fn_name, compute_native_build_artifacts, detect_cycles, ensure_tish_canvas_module,
     export_name_to_rust_ident, extract_native_import_features, format_rust_dependencies_toml,
     generate_native_wrapper_rs, has_external_native_imports, has_native_imports,
-    infer_native_module_exports, is_builtin_native_spec, is_cargo_native_spec, is_native_import,
+    ffi_native_specs, infer_native_module_exports, is_builtin_native_spec, is_cargo_native_spec,
+    is_ffi_native_spec, is_native_import,
     merge_modules, normalize_builtin_spec, program_uses_document, read_project_tish_config,
     resolve_bare_spec, resolve_native_modules, resolve_project, resolve_project_from_stdin,
     MergedProgram, NativeBuildArtifacts, NativeModuleInit, ResolvedNativeModule,
@@ -40,9 +44,9 @@ mod tests {
 
     #[test]
     fn typed_assign_conversion() {
-        // With the inference pass and native emit, `total: number = 0` becomes f64.
-        // Assignment `total = total + n` (where n comes from ForOf over a Value::Array)
-        // emits a native f64 assignment that unboxes the Value result via from_value_expr.
+        // Typed rest-param `...args: number[]` lowers to a native `Vec<f64>` (M3), so the ForOf
+        // element `n` is `f64`, `total = total + n` stays native, and `total` is NOT demoted — the
+        // whole reduction compiles to native f64 with the return wrapping `total` back to `Value`.
         let src = r#"
 fn sum(...args: number[]): number {
     let total: number = 0
@@ -52,12 +56,33 @@ fn sum(...args: number[]): number {
 "#;
         let program = parse(src).unwrap();
         let rust = compile(&program).unwrap();
-        // total should be declared as f64
-        assert!(rust.contains("let mut total: f64"), "expected total: f64");
-        // The return value of run() should convert total back to Value
+        assert!(
+            rust.contains("let mut total: f64"),
+            "typed rest-param `Vec<f64>` keeps `total` native f64 (no demotion)"
+        );
+        assert!(
+            rust.contains("Value::Number(total)"),
+            "f64 total is wrapped back to Value at the return boundary"
+        );
+
+        // When every reassignment is provably numeric, the `number` local stays native `f64` and
+        // is wrapped back to `Value` only at the return boundary.
+        let src_native = r#"
+fn count(): number {
+    let total: number = 0
+    for (let i: number = 0; i < 10; i = i + 1) { total = total + i }
+    return total
+}
+"#;
+        let program = parse(src_native).unwrap();
+        let rust = compile(&program).unwrap();
+        assert!(
+            rust.contains("let mut total: f64"),
+            "numeric-only reassignment keeps `total` native f64"
+        );
         assert!(
             rust.contains("Value::Number(total)"),
-            "expected Value::Number(total) wrapping"
+            "f64 total is wrapped back to Value at the return boundary"
         );
     }
 
@@ -162,3 +187,20 @@ fn factory() {
         );
     }
 }
+
+#[cfg(test)]
+mod monomorphization_tests {
+    use super::*;
+    use tishlang_parser::parse;
+
+    /// `Box<number>` monomorphizes to a synthetic concrete alias whose field is a native `f64`,
+    /// not a boxed `Value` — generic structs participate in native lowering.
+    #[test]
+    fn generic_struct_is_native() {
+        let src = "type Box<T> = { value: T }\nlet b: Box<number> = { value: 42 }\nconsole.log(b.value + 1)";
+        let rust = compile(&parse(src).unwrap()).unwrap();
+        // Box<number> must monomorphize to a struct with a native f64 field (not Value).
+        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"));
+    }
+}