fix(codegen-deno): truncate Int/Int division instead of float divide (#478)

JS `/` is floating-point, so the type-erased Deno-ESM backend lowered
integer `a / b` to a non-integer (255 / 16 -> 15.9375). Lower a provably
`Int / Int` to `Math.trunc(a / b)` (truncate toward zero, matching the
interpreter's OCaml `/` and wasm's i32.div_s); every other `/` stays
plain float division, so Float/Float is untouched.

Since codegen_deno is type-erased, a conservative classifier (expr_is_int
/ expr_is_int_array) reports Int only when provable:
  - int literals; Int-typed params; let/assign-tracked Int locals
  - integer-closed arithmetic (+ - * / %); JS bitwise results (int32)
  - calls to Int-returning fns/builtins
  - `for x in xs` loop variable when xs is a provable Array<Int>
  - `xs[i]` element read from a provable Array<Int>
Unknown operands keep `/`, so float division is never silently
truncated. int_vars/int_array_vars are reset per function (enter_fn_scope);
the let-binding and for-loop scopes are restored after their body so a
same-named outer Float is never affected; `x /= y` over ints truncates.

Fixes stdlib/math.affine integer fns (pow, sum_naturals, binomial, lcm,
div_floor) and `for x in xs { ... x / k ... }` over int arrays on the
Deno-ESM backend.

Verified locally (apt toolchain): dune build bin/main.exe clean;
tests/codegen-deno/int_div regression passes (truncation, toward-zero on
negatives, float preserved incl. Array<Float> loops, loop-mutated locals,
Int-returning-call operands, for-loop var + indexed Array<Int>, /=); full
codegen-deno + codegen-wasm suites and dune runtest green. (Full
`dune build`/@fmt need js_of_ocaml+ocamlformat, absent in this sandbox
but present in CI.)

Refs #478.

Author: claude

lib/codegen_deno.ml

@@ -68,6 +68,25 @@ type codegen_ctx = {
      `await` it (e.g. `get(u).status` would otherwise read `.status` off
      a pending Promise). Populated in {!generate}. *)
   async_fns : (string, unit) Hashtbl.t;
+  (* Top-level functions whose declared return type is [Int]. Used by
+     {!expr_is_int} so a call like [gcd(a, b)] counts as an integer
+     operand — needed to truncate e.g. [abs(a*b) / gcd(a,b)]. Populated
+     in {!generate}. *)
+  int_fns : (string, unit) Hashtbl.t;
+  (* Names bound to a provably-[Int] value in the *current function*:
+     [Int]-typed params plus [let]/assignments whose value is an integer
+     expression. Mutated in source order as statements are emitted (the
+     existing per-statement {!List.iter} makes this order-correct), and
+     reset per function so names never leak across functions. Drives the
+     [Int / Int -> Math.trunc(a / b)] lowering (issue #478); an unknown
+     operand keeps plain [/], so float division is never affected. *)
+  mutable int_vars : (string, unit) Hashtbl.t;
+  (* Names provably bound to an [Array<Int>] (i.e. `[Int]`) in the
+     *current function*: array-typed params. Lets a `for x in xs` over an
+     int array seed [x] as [Int], and an `xs[i]` element read count as an
+     integer operand, so divisions over them truncate (#478). Reset per
+     function alongside {!int_vars}. *)
+  int_array_vars : (string, unit) Hashtbl.t;
   (* True while emitting a synthesised `async` method body. The
      expression-position IIFE wrappers (block/try/match/let/return) must
      then be `async` and awaited, because they may contain an awaited
@@ -85,6 +104,9 @@ let create_ctx symbols = {
   assoc = Hashtbl.create 32;
   local_fns = Hashtbl.create 64;
   async_fns = Hashtbl.create 32;
+  int_fns = Hashtbl.create 64;
+  int_vars = Hashtbl.create 16;
+  int_array_vars = Hashtbl.create 16;
   in_async = false;
 }
 
@@ -632,6 +654,104 @@ let resolve_var ctx (name : string) : string =
   | Some s when s = name -> "this"
   | _ -> mangle name
 
+(* ============================================================================
+   Integer-operand inference for division (issue #478)
+
+   The Deno-ESM backend is type-erased, but JS `/` is floating-point, so a
+   naive `OpDiv -> "/"` turns `255 / 16` into `15.9375`. We lower an
+   `Int / Int` to `Math.trunc(a / b)` (truncate-toward-zero, matching the
+   interpreter's OCaml `/` and wasm's `i32.div_s`) and leave every other
+   `/` as plain float division. The classifier below is deliberately
+   conservative: it reports [true] only when an operand is *provably* an
+   integer, so a value of unknown type keeps `/` and float division is
+   never silently truncated.
+   ============================================================================ *)
+
+(* [Int] head of a (possibly ref/own/mut) type expression. Only the
+   nominal [Int] constructor counts; type variables / applications do not. *)
+let rec type_head_is_int : type_expr -> bool = function
+  | TyCon id -> id.name = "Int"
+  | TyOwn t | TyRef t | TyMut t -> type_head_is_int t
+  | _ -> false
+
+(* Is [t] an [Array<Int>] (surface `[Int]`, which the parser desugars to
+   `Array[Int]`)? Used to seed for-loop variables and recognise indexed
+   element reads as integers (#478). *)
+let rec type_is_int_array : type_expr -> bool = function
+  | TyApp (id, [ TyArg elem ]) -> id.name = "Array" && type_head_is_int elem
+  | TyOwn t | TyRef t | TyMut t -> type_is_int_array t
+  | _ -> false
+
+(* Simple-variable pattern name, if [pat] binds exactly one name. *)
+let pat_var_name : pattern -> string option = function
+  | PatVar id -> Some id.name
+  | _ -> None
+
+(* Builtins whose return type is unambiguously [Int]. Calls to these count
+   as integer operands. (Excludes e.g. [parse_int], which is Option<Int>.) *)
+let int_returning_builtins =
+  [ "len"; "string_find"; "string_char_code_at"; "char_to_int";
+    "string_length" ]
+
+(* Conservative "is this expression provably an [Int]?" Used only to decide
+   whether a `/` should truncate; a [false] is always safe (keeps `/`). *)
+let rec expr_is_int ctx (e : expr) : bool =
+  match e with
+  | ExprLit (LitInt _) -> true
+  | ExprLit _ -> false
+  | ExprSpan (e, _) -> expr_is_int ctx e
+  | ExprVar id -> Hashtbl.mem ctx.int_vars id.name
+  (* Integer-closed arithmetic: result is [Int] iff both operands are.
+     [OpDiv] is included because the emission below makes `Int / Int`
+     truncate, so it too yields an [Int]. *)
+  | ExprBinary (a, (OpAdd | OpSub | OpMul | OpDiv | OpMod), b) ->
+      expr_is_int ctx a && expr_is_int ctx b
+  (* JS bitwise operators coerce to a 32-bit integer regardless of input,
+     so the result is always an integer. *)
+  | ExprBinary (_, (OpBitAnd | OpBitOr | OpBitXor | OpShl | OpShr), _) -> true
+  | ExprUnary (OpNeg, e) -> expr_is_int ctx e
+  | ExprUnary (OpBitNot, _) -> true
+  | ExprIf { ei_then; ei_else = Some e; _ } ->
+      expr_is_int ctx ei_then && expr_is_int ctx e
+  | ExprApp (ExprVar id, _) ->
+      Hashtbl.mem ctx.int_fns id.name
+      || List.mem id.name int_returning_builtins
+  (* An element read from a provably-[Array<Int>] value is an [Int]
+     (covers `xs[i] / 2` where xs: [Int]) — issue #478 finding 2. *)
+  | ExprIndex (arr, _) -> expr_is_int_array ctx arr
+  | _ -> false
+
+(* Conservative "is this expression provably an [Array<Int>]?" Recognises
+   int-array params/locals and array literals whose every element is an
+   integer. As with {!expr_is_int}, a [false] is always safe. *)
+and expr_is_int_array ctx (e : expr) : bool =
+  match e with
+  | ExprSpan (e, _) -> expr_is_int_array ctx e
+  | ExprVar id -> Hashtbl.mem ctx.int_array_vars id.name
+  | ExprArray elems -> elems <> [] && List.for_all (expr_is_int ctx) elems
+  | _ -> false
+
+(* Record/forget whether [name] currently holds an [Int], after a binding
+   or assignment of [value] to it. Keeps {!ctx.int_vars} in sync as a
+   function body is emitted top-to-bottom. *)
+let track_int_binding ctx (name : string) (value : expr) : unit =
+  if expr_is_int ctx value then Hashtbl.replace ctx.int_vars name ()
+  else Hashtbl.remove ctx.int_vars name
+
+(* Reset [int_vars] / [int_array_vars] for a new function body and seed
+   them from [Int]- and [Array<Int>]-typed params. Returns [ctx] with the
+   fresh tables installed. *)
+let enter_fn_scope ctx (params : param list) : codegen_ctx =
+  let tbl = Hashtbl.create 16 in
+  let arr_tbl = Hashtbl.create 16 in
+  List.iter
+    (fun (p : param) ->
+      if type_head_is_int p.p_ty then Hashtbl.replace tbl p.p_name.name ()
+      else if type_is_int_array p.p_ty then
+        Hashtbl.replace arr_tbl p.p_name.name ())
+    params;
+  { ctx with int_vars = tbl; int_array_vars = arr_tbl }
+
 (* ============================================================================
    Expression code generation
 
@@ -690,6 +810,11 @@ let rec gen_expr ctx (expr : expr) : string =
       (* `++` is string- OR array-concat; dispatch on shape at runtime so
          `a ++ b` (string) and `acc ++ [x]` (array) are both correct. *)
       "__as_concat(" ^ gen_expr ctx e1 ^ ", " ^ gen_expr ctx e2 ^ ")"
+  | ExprBinary (e1, OpDiv, e2) when expr_is_int ctx e1 && expr_is_int ctx e2 ->
+      (* Issue #478: integer `/` truncates toward zero; JS `/` is float.
+         Both operands are provably [Int] here, so emit a truncating
+         divide that matches the interpreter and wasm backends. *)
+      "Math.trunc((" ^ gen_expr ctx e1 ^ ") / (" ^ gen_expr ctx e2 ^ "))"
   | ExprBinary (e1, op, e2) ->
       let op_str = match op with
         | OpAdd -> "+" | OpSub -> "-" | OpMul -> "*" | OpDiv -> "/"
@@ -716,13 +841,28 @@ let rec gen_expr ctx (expr : expr) : string =
       let pat_str = gen_pattern ctx el_pat in
       let val_str = gen_expr ctx el_value in
       let kw = if el_mut then "let" else "const" in
-      (match el_body with
-       | Some body ->
-           iife ctx (kw ^ " " ^ pat_str ^ " = " ^ val_str ^ "; return "
-                     ^ gen_expr ctx body ^ ";")
-       | None ->
-           iife ctx (kw ^ " " ^ pat_str ^ " = " ^ val_str
-                     ^ "; return Unit;"))
+      (* `let x = v in body` is lexically scoped, so track [x]'s int-ness
+         only for [body] and restore afterward — a leaked binding could
+         wrongly truncate a same-named outer Float (#478). *)
+      let body_str =
+        match el_body with
+        | Some body ->
+            let restore =
+              match pat_var_name el_pat with
+              | Some n ->
+                  let had = Hashtbl.mem ctx.int_vars n in
+                  track_int_binding ctx n el_value;
+                  fun () ->
+                    if had then Hashtbl.replace ctx.int_vars n ()
+                    else Hashtbl.remove ctx.int_vars n
+              | None -> fun () -> ()
+            in
+            let b = gen_expr ctx body in
+            restore ();
+            kw ^ " " ^ pat_str ^ " = " ^ val_str ^ "; return " ^ b ^ ";"
+        | None -> kw ^ " " ^ pat_str ^ " = " ^ val_str ^ "; return Unit;"
+      in
+      iife ctx body_str
   | ExprTuple exprs | ExprArray exprs ->
       "[" ^ String.concat ", " (List.map (gen_expr ctx) exprs) ^ "]"
   | ExprIndex (arr, idx) ->
@@ -993,26 +1133,73 @@ and gen_stmt ctx (stmt : stmt) : string =
   match stmt with
   | StmtLet { sl_pat; sl_value; sl_mut; sl_quantity = _; sl_ty = _ } ->
       let kw = if sl_mut then "let" else "const" in
-      kw ^ " " ^ gen_pattern ctx sl_pat ^ " = " ^ gen_expr ctx sl_value ^ ";"
+      let js = kw ^ " " ^ gen_pattern ctx sl_pat ^ " = "
+               ^ gen_expr ctx sl_value ^ ";" in
+      (* Track an [Int]-bound name for the rest of this body (#478). A
+         block statement's scope is the enclosing function, which
+         {!enter_fn_scope} already bounds, so no restore is needed here. *)
+      (match pat_var_name sl_pat with
+       | Some n -> track_int_binding ctx n sl_value
+       | None -> ());
+      js
   | StmtExpr e -> gen_stmt_expr ctx e
   | StmtAssign (lhs, op, rhs) ->
-      let op_str = match op with
-        | AssignEq -> "=" | AssignAdd -> "+=" | AssignSub -> "-="
-        | AssignMul -> "*=" | AssignDiv -> "/="
+      (* #478: `x /= y` over integers must truncate, like `x = x / y`. *)
+      let div_int =
+        op = AssignDiv && expr_is_int ctx lhs && expr_is_int ctx rhs in
+      let js =
+        if div_int then
+          let t = gen_expr ctx lhs in
+          t ^ " = Math.trunc(" ^ t ^ " / (" ^ gen_expr ctx rhs ^ "));"
+        else
+          let op_str = match op with
+            | AssignEq -> "=" | AssignAdd -> "+=" | AssignSub -> "-="
+            | AssignMul -> "*=" | AssignDiv -> "/="
+          in
+          gen_expr ctx lhs ^ " " ^ op_str ^ " " ^ gen_expr ctx rhs ^ ";"
       in
-      gen_expr ctx lhs ^ " " ^ op_str ^ " " ^ gen_expr ctx rhs ^ ";"
+      (* Keep int-tracking current across reassignment of a simple var. *)
+      (match lhs, op with
+       | ExprVar id, AssignEq -> track_int_binding ctx id.name rhs
+       | ExprVar id, AssignDiv ->
+           if div_int then Hashtbl.replace ctx.int_vars id.name ()
+           else Hashtbl.remove ctx.int_vars id.name
+       | ExprVar id, (AssignAdd | AssignSub | AssignMul) ->
+           if not (expr_is_int ctx rhs) then
+             Hashtbl.remove ctx.int_vars id.name
+       | _ -> ());
+      js
   | StmtWhile (cond, body) ->
       "while (" ^ gen_expr ctx cond ^ ") { "
       ^ String.concat " " (List.map (gen_stmt ctx) body.blk_stmts)
       ^ (match body.blk_expr with
          | Some e -> " " ^ gen_stmt_expr ctx e | None -> "")
       ^ " }"
   | StmtFor (pat, iter, body) ->
-      "for (const " ^ gen_pattern ctx pat ^ " of " ^ gen_expr ctx iter ^ ") { "
-      ^ String.concat " " (List.map (gen_stmt ctx) body.blk_stmts)
-      ^ (match body.blk_expr with
-         | Some e -> " " ^ gen_stmt_expr ctx e | None -> "")
-      ^ " }"
+      (* The iterable is evaluated in the outer scope, so emit it first. *)
+      let iter_str = gen_expr ctx iter in
+      let pat_str = gen_pattern ctx pat in
+      (* #478: a `for x in xs` over a provably-[Array<Int>] binds [x] to an
+         [Int] each iteration, so `x / 2` in the body must truncate. The
+         loop variable is loop-scoped, so save/restore its [int_vars] entry
+         to avoid leaking onto a same-named outer binding after the loop. *)
+      let restore =
+        match pat_var_name pat with
+        | Some n when expr_is_int_array ctx iter ->
+            let had = Hashtbl.mem ctx.int_vars n in
+            Hashtbl.replace ctx.int_vars n ();
+            fun () ->
+              if had then Hashtbl.replace ctx.int_vars n ()
+              else Hashtbl.remove ctx.int_vars n
+        | _ -> fun () -> ()
+      in
+      let body_js =
+        String.concat " " (List.map (gen_stmt ctx) body.blk_stmts)
+        ^ (match body.blk_expr with
+           | Some e -> " " ^ gen_stmt_expr ctx e | None -> "")
+      in
+      restore ();
+      "for (const " ^ pat_str ^ " of " ^ iter_str ^ ") { " ^ body_js ^ " }"
 
 (* ============================================================================
    Top-level declarations + class emission
@@ -1046,7 +1233,7 @@ let gen_function ctx (fd : fn_decl) : unit =
     else async_kw ^ "function" in
   emit_line ctx
     (Printf.sprintf "%s %s(%s) {" kw name (String.concat ", " params));
-  let body_ctx = increase_indent ctx in
+  let body_ctx = enter_fn_scope (increase_indent ctx) fd.fd_params in
   let body_ctx =
     if is_async then { body_ctx with in_async = true } else body_ctx in
   gen_body body_ctx fd.fd_body;
@@ -1115,7 +1302,7 @@ let gen_method ctx ~(recv_name : string) ~(js_name : string)
   emit_line ctx_m
     (Printf.sprintf "async %s(%s) {" (mangle js_name)
        (String.concat ", " params));
-  gen_body (increase_indent ctx_m) fd.fd_body;
+  gen_body (enter_fn_scope (increase_indent ctx_m) fd.fd_params) fd.fd_body;
   emit_line ctx_m "}";
   emit ctx_m ""
 
@@ -1126,7 +1313,7 @@ let gen_constructor ctx (fd : fn_decl) : unit =
     List.map (fun (p : param) -> mangle p.p_name.name) fd.fd_params in
   emit_line ctx
     (Printf.sprintf "constructor(%s) {" (String.concat ", " params));
-  let body_ctx = increase_indent ctx in
+  let body_ctx = enter_fn_scope (increase_indent ctx) fd.fd_params in
   let rec assign_record e =
     match e with
     | ExprSpan (inner, _) -> assign_record inner
@@ -1223,12 +1410,23 @@ let generate (program : program) (symbols : Symbol.t) : string =
     | TopFn fd ->
         Hashtbl.replace ctx.local_fns fd.fd_name.name ();
         if fd_is_async fd then
-          Hashtbl.replace ctx.async_fns fd.fd_name.name ()
+          Hashtbl.replace ctx.async_fns fd.fd_name.name ();
+        (* Record [Int]-returning fns so calls to them count as integer
+           operands for the truncating-division lowering (#478). *)
+        (match fd.fd_ret_ty with
+         | Some t when type_head_is_int t ->
+             Hashtbl.replace ctx.int_fns fd.fd_name.name ()
+         | _ -> ())
     | TopConst { tc_name; _ } ->
         Hashtbl.replace ctx.local_fns tc_name.name ()
     | TopImpl ib ->
         List.iter (function
-          | ImplFn fd -> Hashtbl.replace ctx.local_fns fd.fd_name.name ()
+          | ImplFn fd ->
+              Hashtbl.replace ctx.local_fns fd.fd_name.name ();
+              (match fd.fd_ret_ty with
+               | Some t when type_head_is_int t ->
+                   Hashtbl.replace ctx.int_fns fd.fd_name.name ()
+               | _ -> ())
           | ImplType _ -> ()) ib.ib_items
     | _ -> ()) program.prog_decls;