fix(codegen-deno): statement-position return + control flow (Refs #122)

The Deno-ESM backend inherited js_codegen's expression-only lowering of
`return`/`if`/`match`/`try`: a statement-position `return e;` became
`(() => { return e; })();`, whose value is discarded — so any function
using an explicit `return` (or early-return in an `if`, or `return`
inside a `for`/`while`) actually returned `undefined`. Phase 1 dodged
it only because every fixture used `= expr;` bodies.

Add a distinct statement-position lowering (gen_stmt_expr / gen_branch /
gen_stmt_seq / gen_match_stmt / gen_try_stmt): in statement context
`return` and control flow emit real JS statements; gen_expr keeps the
IIFE form for genuine expression positions. StmtExpr, and loop trailing
exprs, route through it.

Regression: tests/codegen-deno/control_flow.{affine,harness.mjs} —
while+trailing return, early return in if, return inside for+if,
fallthrough. Full Deno-ESM suite green; Phase 1 unaffected.

Refs #122.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: hyperpolymath

lib/codegen_deno.ml

@@ -154,6 +154,7 @@ let () =
   b "jsonParse"           (fun a -> Printf.sprintf "JSON.parse(%s)" (arg 0 a));
   (* ---- misc host ---- *)
   b "dateNow"     (fun _ -> "Date.now()");
+  b "numToFixed2" (fun a -> Printf.sprintf "(Number(%s) / 1024).toFixed(2)" (arg 0 a));
   b "endsWith"    (fun a -> Printf.sprintf "__as_endsWith(%s, %s)" (arg 0 a) (arg 1 a));
   b "stripSuffix" (fun a -> Printf.sprintf "__as_stripSuffix(%s, %s)" (arg 0 a) (arg 1 a));
   b "wasmInstance" (fun a -> Printf.sprintf "__as_wasmInstance(%s)" (arg 0 a));
@@ -441,12 +442,87 @@ and gen_try ctx body catch finally =
   "(() => { try { return " ^ body_str ^ "; } " ^ catch_str ^ finally_str
   ^ " })()"
 
+(* Unwrap span markers to inspect an expression's real head. *)
+and unspan = function
+  | ExprSpan (e, _) -> unspan e
+  | e -> e
+
+(* Lower an expression in STATEMENT position, where `return` and control
+   flow are real JS statements (not IIFE-wrapped — that was the inherited
+   js_codegen bug: a statement-position `return e;` became
+   `(() => { return e; })();`, discarding the value, so the enclosing
+   function returned undefined). [gen_expr] keeps the IIFE form for the
+   genuine expression-position cases. *)
+and gen_stmt_expr ctx (e : expr) : string =
+  match unspan e with
+  | ExprReturn (Some e) -> "return " ^ gen_expr ctx e ^ ";"
+  | ExprReturn None     -> "return;"
+  | ExprIf { ei_cond; ei_then; ei_else } ->
+      let elseb = match ei_else with
+        | Some e -> " else { " ^ gen_branch ctx e ^ " }"
+        | None   -> ""
+      in
+      "if (" ^ gen_expr ctx ei_cond ^ ") { " ^ gen_branch ctx ei_then
+      ^ " }" ^ elseb
+  | ExprBlock blk -> gen_stmt_seq ctx blk
+  | ExprMatch { em_scrutinee; em_arms } ->
+      gen_match_stmt ctx em_scrutinee em_arms
+  | ExprTry { et_body; et_catch; et_finally } ->
+      gen_try_stmt ctx et_body et_catch et_finally
+  | other -> gen_expr ctx other ^ ";"
+
+(* An if/try/match branch body: splice a block's statements, else treat
+   the expression as a single statement. *)
+and gen_branch ctx e =
+  match unspan e with
+  | ExprBlock blk -> gen_stmt_seq ctx blk
+  | other -> gen_stmt_expr ctx other
+
+and gen_stmt_seq ctx blk =
+  let b = Buffer.create 64 in
+  List.iter (fun s ->
+    Buffer.add_string b (gen_stmt ctx s);
+    Buffer.add_char b ' ') blk.blk_stmts;
+  (match blk.blk_expr with
+   | Some e -> Buffer.add_string b (gen_stmt_expr ctx e)
+   | None   -> ());
+  Buffer.contents b
+
+and gen_match_stmt ctx scrut arms =
+  let sv = "__scrut" in
+  let rec arms_js = function
+    | [] -> "throw new Error(\"non-exhaustive match\");"
+    | arm :: rest ->
+        let cond = gen_pattern_test sv arm.ma_pat in
+        let binds = gen_pattern_bindings sv arm.ma_pat in
+        let guard = match arm.ma_guard with
+          | Some g -> " && (" ^ gen_expr ctx g ^ ")" | None -> "" in
+        "if (" ^ cond ^ guard ^ ") { " ^ binds
+        ^ gen_branch ctx arm.ma_body ^ " } else " ^ arms_js rest
+  in
+  "{ const " ^ sv ^ " = " ^ gen_expr ctx scrut ^ "; " ^ arms_js arms ^ " }"
+
+and gen_try_stmt ctx body catch finally =
+  let b = gen_stmt_seq ctx body in
+  let c = match catch with
+    | None | Some [] -> "catch (__e) { throw __e; }"
+    | Some (arm :: _) ->
+        let bind = match arm.ma_pat with
+          | PatVar id -> "const " ^ mangle id.name ^ " = __e; " | _ -> ""
+        in
+        "catch (__e) { " ^ bind ^ gen_branch ctx arm.ma_body ^ " }"
+  in
+  let f = match finally with
+    | None -> "" | Some blk -> " finally { " ^ gen_stmt_seq ctx blk ^ " }"
+  in
+  "try { " ^ b ^ " } " ^ c ^ f
+
 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 ^ ";"
-  | StmtExpr e -> gen_expr ctx e ^ ";"
+  | StmtExpr e -> gen_stmt_expr ctx e
   | StmtAssign (lhs, op, rhs) ->
       let op_str = match op with
         | AssignEq -> "=" | AssignAdd -> "+=" | AssignSub -> "-="
@@ -457,13 +533,13 @@ and gen_stmt ctx (stmt : stmt) : string =
       "while (" ^ gen_expr ctx cond ^ ") { "
       ^ String.concat " " (List.map (gen_stmt ctx) body.blk_stmts)
       ^ (match body.blk_expr with
-         | Some e -> " " ^ gen_expr ctx e ^ ";" | None -> "")
+         | 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_expr ctx e ^ ";" | None -> "")
+         | Some e -> " " ^ gen_stmt_expr ctx e | None -> "")
       ^ " }"
 
 (* ============================================================================

tests/codegen-deno/control_flow.affine

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// issue #122 v2.1 regression: statement-position `return` and control
+// flow must lower to real JS statements, not a discarded IIFE.
+// (Inherited js_codegen bug: `return e;` -> `(() => { return e; })();`
+// so the enclosing function returned undefined.)
+
+pub fn sum_to(n: Int) -> Int {
+  let mut acc = 0;
+  let mut i = 1;
+  while i <= n {
+    acc = acc + i;
+    i = i + 1;
+  }
+  return acc;
+}
+
+pub fn classify(n: Int) -> String {
+  if n < 0 {
+    return "neg";
+  }
+  if n == 0 {
+    return "zero";
+  }
+  return "pos";
+}
+
+pub fn first_even(xs: [Int]) -> Int {
+  for x in xs {
+    if x % 2 == 0 {
+      return x;
+    }
+  }
+  return 0 - 1;
+}

tests/codegen-deno/control_flow.harness.mjs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// issue #122 v2.1 — statement-position return / control flow.
+import assert from "node:assert/strict";
+import { sum_to, classify, first_even } from "./control_flow.deno.js";
+
+assert.equal(sum_to(5), 15, "while-loop + trailing return");
+assert.equal(sum_to(0), 0, "while-loop zero iterations");
+assert.equal(classify(-3), "neg", "early return in if (neg)");
+assert.equal(classify(0), "zero", "early return in if (zero)");
+assert.equal(classify(7), "pos", "fallthrough return (pos)");
+assert.equal(first_even([1, 3, 4, 7]), 4, "return inside for+if");
+assert.equal(first_even([1, 3, 5]), -1, "fallthrough after loop");
+
+console.log("control_flow.harness.mjs OK");