feat(effects+codegen): implement interpreter effect dispatch + BUG-005 WasmGC silent-fallback fix

BUG-005 (codegen_gc.ml):
- Add `UnboundFunction of string` error variant; replace the silent drop+null
  fallback in `ExprApp (ExprVar id, args)` when the function is absent from
  `func_indices` — was producing valid but semantically wrong WASM with no
  diagnostic.
- Replace the silent drop+null fallback in `ExprApp (callee, args)` (indirect /
  higher-order calls) with `UnsupportedFeature`; call_ref is not yet wired.
- Add `UnboundFunction` case to `format_codegen_error`.

Effects runtime (interp.ml):
- `eval_decl TopEffect`: register each effect op as a `PerformEffect`-raising
  `VBuiltin` so that calling an op actually propagates the effect.  Previously
  the entire `TopEffect` branch was a no-op, making all effect ops unbound.
- Fix multi-arg bug in `ExprHandle` dispatch: `arg_vals` was wrapping multiple
  args into a `VTuple` before binding against handler patterns, making any
  effect op with ≥ 2 params silently fail the `fold_left2` length check.
- Bind the resume continuation under `"__resume__"` in the handler env so that
  the `resume expr` keyword form (`ExprResume`) can find it regardless of what
  name the programmer chose for the continuation parameter.
- `ExprResume`: look up `"__resume__"` in env and call it; fall back to
  returning the arg value when used outside a handler (safe no-op semantics).

Effects runtime (codegen_gc.ml — WasmGC):
- `TopEffect`: register each op as an `unreachable` stub function with correct
  func_indices entry so subsequent function indices are not shifted and direct
  calls trap rather than producing a link error.
- `ExprHandle`: replace silent body-only compilation (which dropped all handler
  arms) with an explicit `UnsupportedFeature` error; full dispatch requires the
  WASM EH proposal or a CPS transform, neither of which is present yet.
- `ExprResume`: same — reject explicitly rather than emitting the bare arg value.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

lib/codegen_gc.ml

@@ -45,6 +45,10 @@ type codegen_error =
   | UnsupportedFeature of string
   | UnboundVariable of string
   | UnboundType of string
+  (** Raised when [ExprApp] names a function that has no entry in [func_indices].
+      This is always a compiler bug — every defined function must be registered
+      before codegen reaches a call-site. *)
+  | UnboundFunction of string
 [@@deriving show]
 
 type 'a cg_result = ('a, codegen_error) Result.t
@@ -355,24 +359,21 @@ let rec gen_gc_expr (ctx : gc_ctx) (expr : expr) : (gc_ctx * gc_instr list) cg_r
         | Some func_idx ->
           Ok (ctx_after_args, arg_codes @ [Std (Wasm.Call func_idx)])
         | None ->
-          (* Function index not found: emit drop for all args + null as placeholder *)
-          let drop_code = List.init (List.length args) (fun _ -> std Wasm.Drop) in
-          Ok (ctx_after_args, arg_codes @ drop_code @ [RefNull HtAny])
+          (* BUG-005: every reachable function must be registered in func_indices
+             before codegen visits any call-site.  Silently emitting drop+null here
+             would produce well-typed but semantically wrong WASM that is impossible
+             to debug at runtime.  Fail loudly instead. *)
+          Error (UnboundFunction id.name)
     end
 
   | ExprApp (callee, args) ->
-    (* Indirect calls or non-variable callees: evaluate and discard for now *)
-    let* (ctx1, callee_code) = gen_gc_expr ctx callee in
-    let* (ctx2, arg_codes_rev) =
-      List.fold_left (fun acc arg ->
-        let* (c, rev_codes) = acc in
-        let* (c', code) = gen_gc_expr c arg in
-        Ok (c', code :: rev_codes)
-      ) (Ok (ctx1, [])) args
-    in
-    let arg_codes = List.concat (List.rev arg_codes_rev) in
-    let drop_code = List.init (List.length args + 1) (fun _ -> std Wasm.Drop) in
-    Ok (ctx2, callee_code @ arg_codes @ drop_code @ [RefNull HtAny])
+    (* BUG-005: indirect / higher-order calls (callee is not a plain ExprVar) are
+       not yet lowered to call_ref in the WasmGC backend.  The old behaviour —
+       evaluate callee+args, drop everything, push null — was silently wrong and
+       would crash at the call-site with an opaque type error.  Reject explicitly
+       until call_ref support is added. *)
+    let _ = (callee, args) in
+    Error (UnsupportedFeature "indirect / higher-order call in WasmGC backend (call_ref not yet implemented)")
 
   (* ── Record allocation (core GC operation) ─────────────────────── *)
 
@@ -739,18 +740,35 @@ let rec gen_gc_expr (ctx : gc_ctx) (expr : expr) : (gc_ctx * gc_instr list) cg_r
 
   (* ── Effect / error-handling passthrough ────────────────────────── *)
 
-  | ExprHandle eh ->
-    (* Effect handlers: compile body only; continuation support deferred *)
-    gen_gc_expr ctx eh.eh_body
+  | ExprHandle _eh ->
+    (* Effect handler dispatch is not implementable in this WasmGC backend
+       without either:
+         - The WASM exception-handling proposal (EH) to propagate PerformEffect
+           across stack frames and capture the perform-site continuation, OR
+         - A whole-program CPS transform before codegen.
+
+       Silently compiling just the body (the previous behaviour) was wrong:
+       any handler arms are dropped, so effects are never caught, and the
+       first `perform` would trap at the op stub rather than dispatch to the
+       correct handler arm.  Fail loudly instead.
+
+       To use algebraic effects, compile with the interpreter backend (-i). *)
+    Error (UnsupportedFeature
+      "effect handler (handle { ... }) in WasmGC backend — \
+       requires WASM EH proposal or CPS transform; use `--interp` / `-i`")
 
   | ExprTry et ->
     gen_gc_block ctx et.et_body
 
-  | ExprResume arg_opt ->
-    begin match arg_opt with
-      | Some e -> gen_gc_expr ctx e
-      | None   -> Ok (ctx, [push_i32 0])
-    end
+  | ExprResume _arg_opt ->
+    (* `resume` is only meaningful inside an effect handler arm.  The WasmGC
+       backend has no handler dispatch (see ExprHandle above), so emitting
+       the argument value here would be silently wrong — the enclosing handle
+       expression already fails with UnsupportedFeature before we ever reach
+       a resume.  Fail consistently. *)
+    Error (UnsupportedFeature
+      "`resume` expression in WasmGC backend — \
+       only valid inside a `handle` block; use `--interp` / `-i`")
 
   | ExprRowRestrict (base, _) ->
     (* Row restriction is type-level; GC pointer is unchanged *)
@@ -1104,9 +1122,46 @@ let gen_gc_decl (ctx : gc_ctx) (decl : top_level) : gc_ctx cg_result =
         Ok ctx
     end
 
-  | TopConst _ | TopEffect _ | TopTrait _ | TopImpl _ ->
+  | TopConst _ | TopTrait _ | TopImpl _ ->
     Ok ctx
 
+  | TopEffect ed ->
+    (* Register each effect operation as an unreachable stub function.
+       This gives each op a valid func_indices entry (so direct calls at
+       least produce a trap rather than a link error), and correctly
+       offsets function indices for all subsequent definitions.
+
+       Full effect handler dispatch requires either:
+         - The WASM exception-handling proposal (EH, standardised 2023) to
+           propagate perform-site continuations across stack frames, OR
+         - A whole-program CPS transform before codegen.
+       Neither is implemented in this backend yet.  Use the interpreter
+       (`-i`) for programs that perform effects.
+
+       All parameters are typed as GcAnyref (conservative): concrete types
+       are not yet propagated from the type-inference pass into codegen. *)
+    let ctx' = List.fold_left (fun ctx (op : effect_op_decl) ->
+      let n_params = List.length op.eod_params in
+      let func_type = GcFuncType {
+        gft_params  = List.init n_params (fun _ -> GcAnyref);
+        gft_results = [GcAnyref];
+      } in
+      let (ctx1, type_idx) = register_gc_type ctx func_type in
+      let func_idx = ctx1.import_count + List.length ctx1.gc_funcs_acc in
+      let stub : gc_func = {
+        gf_type   = type_idx;
+        gf_locals = [];
+        (* Trap immediately: calling an effect op in WasmGC without a
+           handler dispatch mechanism is always a programming error. *)
+        gf_body   = [Std Wasm.Unreachable];
+      } in
+      { ctx1 with
+        func_indices = (op.eod_name.name, func_idx) :: ctx1.func_indices;
+        gc_funcs_acc = ctx1.gc_funcs_acc @ [stub];
+      }
+    ) ctx ed.ed_ops in
+    Ok ctx'
+
 (** {1 Module-level entry point} *)
 
 (** Generate a {!Wasm_gc.gc_module} from an AffineScript program.
@@ -1144,3 +1199,4 @@ let format_codegen_error (e : codegen_error) : string =
   | UnsupportedFeature msg -> Printf.sprintf "GC codegen: unsupported feature: %s" msg
   | UnboundVariable name   -> Printf.sprintf "GC codegen: unbound variable: %s" name
   | UnboundType name       -> Printf.sprintf "GC codegen: unbound type: %s" name
+  | UnboundFunction name   -> Printf.sprintf "GC codegen: function '%s' has no func_indices entry (compiler bug — register before codegen)" name

lib/interp.ml

@@ -251,19 +251,32 @@ let rec eval (env : env) (expr : expr) : value result =
         ) eh.eh_handlers in
         begin match op_arm with
           | Some (HandlerOp (_, pats, body)) ->
-            (* Bind effect arguments to handler parameters.
-               The last parameter is conventionally the resume continuation,
-               but for now we bind a simple identity closure. *)
-            let arg_vals = match args with
-              | [single] -> [single]
-              | multiple -> [VTuple multiple]
-            in
-            let resume_fn = VBuiltin ("resume", fun resume_args ->
+            (* Build the resume continuation.  In this tree-walking interpreter
+               the continuation is shallow: calling resume(v) returns v as the
+               result of the entire `handle` expression.  This is correct for
+               the common single-shot, tail-resume pattern.  Full multi-shot
+               continuations require either OCaml 5 effects or a CPS transform. *)
+            let resume_fn = VBuiltin ("__resume__", fun resume_args ->
               match resume_args with
               | [v] -> Ok v
-              | _ -> Ok VUnit
+              | []  -> Ok VUnit
+              | vs  -> Ok (VTuple vs)
             ) in
-            let all_vals = arg_vals @ [resume_fn] in
+            (* Bind effect argument values to handler patterns.
+               Convention: all declared params first, then the continuation as
+               the last pattern.  Pass args flat (not wrapped in a tuple) so
+               that multi-arg effects bind correctly to separate patterns. *)
+            let all_vals = args @ [resume_fn] in
+            let n_pats = List.length pats in
+            let n_vals = List.length all_vals in
+            (* If the handler omits the continuation param, provide it anyway
+               so that ExprResume still works via the __resume__ env slot. *)
+            let trimmed_vals = List.filteri (fun i _ -> i < n_pats) all_vals in
+            let pad_vals =
+              if n_vals < n_pats then
+                trimmed_vals @ List.init (n_pats - n_vals) (fun _ -> VUnit)
+              else trimmed_vals
+            in
             let bindings = List.fold_left2 (fun acc pat v ->
               match acc with
               | Ok bs ->
@@ -272,21 +285,35 @@ let rec eval (env : env) (expr : expr) : value result =
                   | Error e -> Error e
                 end
               | Error e -> Error e
-            ) (Ok []) pats (List.filteri (fun i _ -> i < List.length pats) all_vals) in
+            ) (Ok []) pats pad_vals in
             let* bindings = bindings in
-            let env' = extend_env_list bindings env in
+            (* Also bind the resume fn under "__resume__" so that the
+               `ExprResume` keyword form can find it regardless of what
+               name the programmer chose for the continuation parameter. *)
+            let env' =
+              extend_env "__resume__" resume_fn
+                (extend_env_list bindings env)
+            in
             eval env' body
           | _ -> Error (RuntimeError ("Unhandled effect: " ^ op_name))
         end
       | Error e -> Error e
     end
 
   | ExprResume arg_opt ->
-    (* Resume is only meaningful inside an effect handler. At the top
-       level it's a no-op that returns the argument or unit. *)
-    begin match arg_opt with
+    (* Evaluate the argument, then call the resume continuation bound in the
+       environment by the enclosing ExprHandle dispatcher.  The continuation
+       is stored under "__resume__" so that the `resume expr` keyword form
+       works without the programmer having to name the continuation parameter.
+       If called outside a handler (no "__resume__" in env), return the value
+       as-is — this matches the surface-syntax intuition "resume x ≈ x". *)
+    let* arg_val = match arg_opt with
       | Some e -> eval env e
-      | None -> Ok VUnit
+      | None   -> Ok VUnit
+    in
+    begin match lookup_env "__resume__" env with
+      | Ok resume_fn -> apply_function resume_fn [arg_val]
+      | Error _      -> Ok arg_val
     end
 
   | ExprTry et ->
@@ -865,10 +892,24 @@ let eval_decl (env : env) (decl : top_level) : env result =
     let* v = eval env tc.tc_value in
     Ok (extend_env tc.tc_name.name v env)
 
-  | TopType _ | TopEffect _ | TopTrait _ | TopImpl _ ->
-    (* Type declarations don't affect runtime *)
+  | TopType _ | TopTrait _ | TopImpl _ ->
+    (* Type/trait/impl declarations don't affect the runtime value environment *)
     Ok env
 
+  | TopEffect ed ->
+    (* Register each effect operation as a PerformEffect-raising builtin.
+       When an effect op is called from within a `handle` expression, the
+       Error(PerformEffect ...) propagates up the call stack until caught by
+       the ExprHandle dispatcher.  Unhandled effects surface as RuntimeError. *)
+    let env' = List.fold_left (fun env (op : effect_op_decl) ->
+      let op_name = op.eod_name.name in
+      let builtin = VBuiltin (op_name, fun args ->
+        Error (PerformEffect (op_name, args))
+      ) in
+      extend_env op_name builtin env
+    ) env ed.ed_ops in
+    Ok env'
+
 (** Evaluate a program *)
 let eval_program (prog : program) : env result =
   let initial_env = create_initial_env () in