Something went wrong. Try again.
The Monad language. Dependent types, functional programming compiled with LLVM. Hobby project. monad-lang.org
dependent-types language compiler programming-language functional-programming
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123/// Regression tests for the closure free-variable-capture fix/// (`plans/implementations/2026-08-28-codegen-closure-free-var-capture.md`).////// `compile_db_lam_ir` (`lang/codegen/emit.mo`) lifts a nested `Term.lam`/// (every do-notation continuation is exactly this shape -- `let x <- e1;/// e2` desugars to `Monad.bind e1 (\x -> e2)`, `lang/types.mo`'s/// `desugar_do_inner`) into a brand-new, independent top-level LLVM/// function. Before this fix, `alloc_closure` was always called with an/// EMPTY capture list, so any reference inside the lifted body to a name/// bound in the ENCLOSING function (e.g. an earlier do-statement's own/// bound name) silently resolved to a register that belongs to the outer/// function and doesn't exist inside the lifted one -- `llc: use of/// undefined value`.////// These tests write real `.mo` source to disk and drive it through the/// SAME pipeline `cli/src/main.mo`'s own `compile_file_codegen` uses/// (`load_file_modules` -> `compile_loaded_modules_to_ir` -> `emit_module`/// -> `llc`/`clang`), rather than hand-building a `Term`/`Def` AST --/// do-notation desugaring, dictionary-passing promotion, and typeclass/// call resolution all need to run for real to reach the actual bug (a/// hand-built AST would have to fake all of that, and would risk testing/// a shape that doesn't match what the parser/desugarer actually produce).////// A plain `let x := 5 in ...` does NOT reach `compile_db_lam_ir` at all/// -- `try_compile_let_beta_db` beta-reduces it to a literal/direct/// binding in the SAME function, so it would falsely "pass" even against/// the pre-fix buggy code. Only a genuine monadic bind (`let x <- e1; e2`,/// or an escaping first-class lambda) forces real lambda-lifting, which is/// why every test below uses `<-`, not `:=`.open IO {println, write_file}use lib::codegen::test::e2e_harness {compile_source_run_expect}/// Primary regression test: `b`'s own bind-continuation transitively/// captures `a` from the enclosing lifted lambda. Uses `I64.add`/// directly (not `+`) to isolate the closure-capture fix from an/// unrelated, pre-existing `HAdd`/typeclass-dispatch gap for the plain/// operator form. Expect 5 + 10 = 15.#[test]def test_bind_capture : IO Bool := let source := "def main (args : List String) : IO I64 := do {\n" ++ " let a <- IO.pure 5;\n" ++ " let b <- IO.pure 10;\n" ++ " return (I64.add a b)\n" ++ "}\n" in compile_source_run_expect source "test_bind_capture" 15/// 3-level nesting: transitive capture must compose across more than/// one level (`c`'s continuation captures both `a` and `b`, each/// itself captured one level down from where it was originally bound)./// Expect 1 + 2 + 3 = 6.#[test]def test_bind_capture_3level : IO Bool := let source := "def main (args : List String) : IO I64 := do {\n" ++ " let a <- IO.pure 1;\n" ++ " let b <- IO.pure 2;\n" ++ " let c <- IO.pure 3;\n" ++ " return (I64.add (I64.add a b) c)\n" ++ "}\n" in compile_source_run_expect source "test_bind_capture_3level" 6/// Sibling-lambda regression test: a plain `let n := 5` (beta-reduced/// inline, NOT lifted) followed by a NESTED do-block (`if verbose then/// do { println ... } else return unit`, itself producing its own/// lifted lambda for its trailing `pure hole` continuation) followed by/// a SECOND, later statement that references `n` (also lifted, as/// every do-notation continuation is). `compile_db_lam_ir` resets its/// own ctx's `locals` to compile a lifted function's body in isolation/// (`ctx_reset_locals`) -- but was returning that RESET ctx straight/// back to its caller instead of restoring the caller's own original/// locals (`ctx_restore_locals`), so `n`'s binding was silently lost/// from the enclosing function's own ctx the moment the FIRST nested/// lambda (the `if`'s own do-block) finished compiling -- the SECOND/// lambda (`return n`) then couldn't find `n` as a local at all (not/// merely failing to capture it -- `n` resolved as an unknown GLOBAL/// name and silently miscompiled into a bogus 0-arg call,/// `llc: use of undefined value '@n'`). This exact shape --/// `compile_loaded_modules_to_ir`'s own `if verbose then do {...}/// else return unit;` pattern, repeated across several successive/// stages -- is what blocked `bootstrap compile cli/src/main.mo monad`'s/// own self-compile. Expect 5 (verbose=false, so `n` survives/// untouched through the discarded `if`/`else` branch).#[test]def test_sibling_lambda_preserves_outer_locals : IO Bool := let source := "def helper (verbose : Bool) : IO I64 := do {\n" ++ " let n := 5;\n" ++ " if verbose then do {\n" ++ " println \"hi\"\n" ++ " } else return unit;\n" ++ " return n\n" ++ "}\n" ++ "def main (args : List String) : IO I64 := helper false\n" in compile_source_run_expect source "test_sibling_lambda_preserves_outer_locals" 5/// Shim-path regression test: a top-level (arity>0) def referenced as a/// first-class VALUE -- passed to another function and applied/// indirectly via `apply_closureN` -- must still work once/// `apply_closureN` uniformly expects every boxed entry to accept a/// leading `self` param. `add_one`'s own DIRECT-call signature (unused/// in this program, but exercised implicitly by every other top-level/// def in the whole corpus) must stay untouched, so this only passes if/// `build_closure_shim_func`'s forwarding shim (not `add_one`'s own/// entry point) is what actually gets boxed and invoked here./// Deliberately avoids `List`/`Option`/`+` machinery (all of which hit/// unrelated, pre-existing gaps -- `List.cons`'s own constructor/// wrapper isn't reachable via this minimal-corpus compile path, and/// `+`'s `HAdd` dispatch has a separate gap) by hand-writing a tiny/// `apply_fn`/`add_one` pair: `apply_fn add_one 8` must produce 9.#[test]def test_shim_boxed_def_as_value : IO Bool := let source := "def add_one (x : I64) : I64 := I64.add x 1\n" ++ "def apply_fn (f : I64 -> I64) (x : I64) : I64 := f x\n" ++ "def main (args : List String) : IO I64 :=\n" ++ " IO.pure (apply_fn add_one 8)\n" in compile_source_run_expect source "test_shim_boxed_def_as_value" 9