JIT: cover option/result/match/closures; clarify it's a method-based baseline JIT

run_jit + jit_supported_instruction now also handle MakeSome, LoadNone,
MakeClosure, MatchOption/Result/Variant, MatchMapGet, UnwrapSome,
UnwrapVariantValue, RuntimeError (exact copies of drive's arms; shared helpers
keep them gap-free). The 3-way parity suite (interp == jit == compiled) exercises
these across option/result/match-heavy fixtures.

docs/jit-todo.md: mark Match* done; document that this is a per-function
(method-based) baseline JIT — not a tracing JIT, and not native codegen yet.

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

Author: Haofei

docs/jit-todo.md

@@ -6,6 +6,21 @@ VM interpreter, the JIT, and the compiled (Rust-lowering) backend.
 Design invariants (must hold at every step): see `docs/jit-roadmap.md`.
 Status legend: `[x]` done · `[ ]` todo · `[~]` in progress.
 
+## What kind of JIT is this?
+
+**Method-based (per-function) baseline JIT — not a tracing JIT, not native (yet).**
+
+- **Per-function, not tracing:** it compiles whole functions, deciding eligibility
+  up front. A tracing JIT instead records hot linear execution *traces* (across
+  call/loop boundaries) and compiles those with guards; we don't do that.
+- **Tier-0 = specializing executor:** today it executes the supported instruction
+  subset via a reduced-dispatch loop (`RegVm::run_jit`) that reuses the
+  interpreter's exact semantics, with per-function fallback. This is gap-free but
+  only a modest speedup (no native code, values still boxed `VmValue`).
+- **Next = native method JIT:** Cranelift codegen + unboxed numeric registers in a
+  separate crate (see below) is where real performance comes from. Tracing could
+  be a later alternative/addition, but the method JIT is the chosen path.
+
 ## Done
 
 - [x] **N-way differential framework** — `Backend` trait (interpreter / jit /
@@ -21,7 +36,10 @@ Status legend: `[x]` done · `[ ]` todo · `[~]` in progress.
 - [x] **Covered instruction subset (tier-0):** loads (unit/int/float/bool/string),
   move, deep-copy, manage, int arithmetic/bitwise/shift, int comparisons,
   equal/not-equal, jumps (uncond / if-bool / if-int-compare), get/set field,
-  make struct/variant/list/object/map, return.
+  make struct/variant/list/object/map, option/result (make-some, load-none,
+  unwrap-some, unwrap-variant-value), match (option/result/variant/map-get),
+  make-closure, runtime-error, return.
+- [x] **Option/Result/match coverage** verified three-way across the parity suite.
 - [x] **Out-of-range int literal rejected at the frontend** (RS0033) — keeps the
   three backends consistent.
 
@@ -32,7 +50,7 @@ Status legend: `[x]` done · `[ ]` todo · `[~]` in progress.
   `try_exec_pure(instr, base, &mut ip)` used by both (structural gap-freeness;
   currently the two copies are guarded only by the differential).
 - [ ] Collection get/set + index ops (List/Map get/set) in the eligible subset.
-- [ ] `Match*` (option/result/variant) in the eligible subset.
+- [x] `Match*` (option/result/variant/map-get) in the eligible subset.
 - [ ] Cross-function: let JIT-compiled code call other functions (needs frame
   push integration) — currently any `Call` makes a function fall back.
 - [ ] Float / string / bytes ops parity coverage in the generator.

src/reg_vm.rs

@@ -99,6 +99,16 @@ fn jit_supported_instruction(instr: &RegInstr) -> bool {
             | RegInstr::MakeList { .. }
             | RegInstr::MakeObject { .. }
             | RegInstr::MakeMap { .. }
+            | RegInstr::MakeSome { .. }
+            | RegInstr::LoadNone { .. }
+            | RegInstr::MakeClosure { .. }
+            | RegInstr::MatchOption { .. }
+            | RegInstr::MatchResult { .. }
+            | RegInstr::MatchVariant { .. }
+            | RegInstr::MatchMapGet { .. }
+            | RegInstr::UnwrapSome { .. }
+            | RegInstr::UnwrapVariantValue { .. }
+            | RegInstr::RuntimeError { .. }
             | RegInstr::AddInt { .. }
             | RegInstr::SubInt { .. }
             | RegInstr::MulInt { .. }
@@ -5070,6 +5080,127 @@ impl RegVm {
                         ip = *target;
                     }
                 }
+                RegInstr::MakeSome { dst, value } => {
+                    let value = self.reg(base + *value).clone();
+                    self.set_reg(base + *dst, VmValue::OptionSome(Box::new(value)));
+                }
+                RegInstr::LoadNone { dst } => {
+                    self.set_reg(base + *dst, VmValue::OptionNone);
+                }
+                RegInstr::MakeClosure {
+                    dst,
+                    function: callee,
+                    captures,
+                } => {
+                    let mut captured = Vec::with_capacity(captures.len());
+                    for reg in captures {
+                        captured.push(self.reg(base + *reg).clone());
+                    }
+                    self.set_reg(
+                        base + *dst,
+                        VmValue::Closure(Rc::new(VmClosure {
+                            function: *callee,
+                            captures: captured,
+                        })),
+                    );
+                }
+                RegInstr::MatchOption {
+                    src,
+                    some_ip,
+                    none_ip,
+                } => match self.reg(base + *src) {
+                    VmValue::OptionSome(_) => ip = *some_ip,
+                    VmValue::OptionNone => ip = *none_ip,
+                    other => {
+                        return Err(EvalError::Runtime(format!(
+                            "reg VM Option match expected Option, got `{}`.",
+                            other.display()
+                        )));
+                    }
+                },
+                RegInstr::MatchResult { src, ok_ip, err_ip } => match self.reg(base + *src) {
+                    VmValue::Variant(data) if data.name.as_ref() == "Ok" => ip = *ok_ip,
+                    VmValue::Variant(data) if data.name.as_ref() == "Err" => ip = *err_ip,
+                    other => {
+                        return Err(EvalError::Runtime(format!(
+                            "reg VM Result match expected Result, got `{}`.",
+                            other.display()
+                        )));
+                    }
+                },
+                RegInstr::MatchVariant {
+                    src,
+                    expected,
+                    match_ip,
+                    else_ip,
+                } => match self.reg(base + *src) {
+                    VmValue::Variant(data) if data.name.as_ref() == expected.as_str() => {
+                        ip = *match_ip
+                    }
+                    VmValue::Variant(_) => ip = *else_ip,
+                    other => {
+                        return Err(EvalError::Runtime(format!(
+                            "reg VM variant match expected `{expected}`, got `{}`.",
+                            other.display()
+                        )));
+                    }
+                },
+                RegInstr::MatchMapGet {
+                    map,
+                    key,
+                    value_dst,
+                    some_ip,
+                    none_ip,
+                } => {
+                    let map = expect_map_ref(self.reg(base + *map))?;
+                    let key = map_key_from_value(self.reg(base + *key))?;
+                    if let Some(value) = map.borrow().get(&key).cloned() {
+                        self.set_reg(base + *value_dst, value);
+                        ip = *some_ip;
+                    } else {
+                        ip = *none_ip;
+                    }
+                }
+                RegInstr::UnwrapSome { dst, src } => {
+                    let value = match self.reg(base + *src) {
+                        VmValue::OptionSome(value) => (**value).clone(),
+                        other => {
+                            return Err(EvalError::Runtime(format!(
+                                "reg VM Some binding expected Some, got `{}`.",
+                                other.display()
+                            )));
+                        }
+                    };
+                    self.set_reg(base + *dst, value);
+                }
+                RegInstr::UnwrapVariantValue { dst, src, expected } => {
+                    let value = match self.reg(base + *src) {
+                        VmValue::Variant(data) if data.name.as_ref() == expected.as_str() => data
+                            .fields
+                            .get("value")
+                            .cloned()
+                            .or_else(|| {
+                                (data.fields.len() == 1)
+                                    .then(|| data.fields.values().next().cloned())
+                                    .flatten()
+                            })
+                            .ok_or_else(|| {
+                                EvalError::Runtime(format!(
+                                    "reg VM `{expected}` variant is missing value."
+                                ))
+                            })?,
+                        other => {
+                            return Err(EvalError::Runtime(format!(
+                                "reg VM expected `{expected}` variant, got `{}`.",
+                                other.display()
+                            )));
+                        }
+                    };
+                    self.set_reg(base + *dst, value);
+                }
+                RegInstr::RuntimeError { message } => {
+                    return Err(EvalError::Runtime(message.clone()));
+                }
                 RegInstr::Return { src } => return Ok(self.take_reg(base + *src)),
                 // Eligibility (`jit_supported_instruction`) guarantees only the
                 // instructions above reach here. A mismatch would be an internal