12537c4 | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

12537c4 — Peter John 2026-07-19T21:52:11+05:30

fix(plum-wasm-codegen): assert/todo trap, tail-position If also diverges

Files changed (2) hide show

plum-wasm-codegen/src/lib.rs +39 -7
plum-wasm-codegen/tests/codegen_tests.rs +54 -0

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -618,6 +618,28 @@ fn compile_block(block: &ast::Block, body: &mut Vec<u8>, ctx: &LocalCtx, state:
     Ok(())
 }
+/// True if control can never fall through past this statement — every reachable path
+/// ends in a `return`. Used to decide whether a tail-position If/Match needs a
+/// trailing `unreachable` to satisfy wasm's per-block (not whole-function) validation
+/// when the function declares a non-Unit return type.
+fn stmt_always_diverges(stmt: &ast::Stmt) -> bool {
+    match stmt {
+        ast::Stmt::Return(_) | ast::Stmt::Todo => true,
+        ast::Stmt::If(if_) => {
+            if_.else_.is_some()
+                && block_always_diverges(&if_.body)
+                && if_.else_ifs.iter().all(|ei| block_always_diverges(&ei.body))
+                && if_.else_.as_ref().is_some_and(block_always_diverges)
+        }
+        ast::Stmt::Match(m) => !m.cases.is_empty() && m.cases.iter().all(|c| block_always_diverges(&c.body)),
+        _ => false,
+    }
+}
+fn block_always_diverges(block: &ast::Block) -> bool {
+    block.stmts.last().map(stmt_always_diverges).unwrap_or(false)
+}
 /// Compiles a block that is the body of a function. If the function returns a value
 /// and the last statement is an expression, that expression's value is left on the
 /// stack instead of being dropped.
@@ -639,14 +661,14 @@ fn compile_block_as_fn_body(
                     compile_expr(e, body, ctx, state)?;
                     // do NOT drop — this is the return value
                 }
-                ast::Stmt::Match(m) => {
+                _ if stmt_always_diverges(last) => {
-                    compile_match(m, body, ctx, state)?;
+                    compile_stmt(last, body, ctx, state)?;
-                    // Every arm of a tail-position match must itself `return`; if a
+                    // Every branch of this If/Match already `return`s; if it somehow
-                    // non-exhaustive match falls through, trap rather than continue
+                    // falls through anyway (a bug, or a non-exhaustive match), trap
-                    // with the required-but-never-produced result value missing.
+                    // rather than continue with the required result value missing.
                     // This also satisfies wasm validation, which requires a value at
                     // the function's `end` regardless of whether every branch inside
-                    // the match's (BlockType::Empty) if/else chain already returned.
+                    // an (BlockType::Empty) if/else chain already returned.
                     Instruction::Unreachable.encode(body);
                 }
                 _ => {
@@ -764,7 +786,17 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
         ast::Stmt::Match(m) => {
             compile_match(m, body, ctx, state)?;
         }
-        ast::Stmt::Assert(_) | ast::Stmt::Todo => {}
+        ast::Stmt::Assert(e) => {
+            compile_expr(e, body, ctx, state)?;
+            Instruction::I32Eqz.encode(body);
+            Instruction::If(BlockType::Empty).encode(body);
+            Instruction::Unreachable.encode(body);
+            Instruction::End.encode(body);
+        }
+        ast::Stmt::Todo => {
+            // Marks an unimplemented body — trap rather than silently continuing.
+            Instruction::Unreachable.encode(body);
+        }
     }
     Ok(())
 }

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -305,3 +305,57 @@ main() -> Int =
     let bytes = compile_source(&source).expect("compile failed");
     assert_eq!(run_main(&bytes), 42);
 }
+#[test]
+fn assert_traps_on_false_and_passes_through_on_true() {
+    let src_ok = "\
+check(n: Int) -> Int =
+  assert n > 0
+  n
+main() -> Int =
+  check(5)
+";
+    let source = parse(src_ok);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 5);
+    let src_trap = "\
+check(n: Int) -> Int =
+  assert n > 0
+  n
+main() -> Int =
+  check(-1)
+";
+    let source = parse(src_trap);
+    let bytes = compile_source(&source).expect("compile failed");
+    let engine = wasmtime::Engine::default();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let instance = wasmtime::Instance::new(&mut store, &module, &[]).unwrap();
+    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+    let err = main.call(&mut store, ()).expect_err("a false assert should trap, not silently continue");
+    assert_eq!(err.downcast_ref::<wasmtime::Trap>(), Some(&wasmtime::Trap::UnreachableCodeReached), "got: {}", err);
+}
+#[test]
+fn todo_traps_at_runtime() {
+    // `todo` marks an unimplemented body — it must trap, not silently do nothing.
+    let src = "\
+notDoneYet() -> Int =
+  todo
+main() -> Int =
+  notDoneYet()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    let engine = wasmtime::Engine::default();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let instance = wasmtime::Instance::new(&mut store, &module, &[]).unwrap();
+    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
+    let err = main.call(&mut store, ()).expect_err("todo should trap");
+    assert_eq!(err.downcast_ref::<wasmtime::Trap>(), Some(&wasmtime::Trap::UnreachableCodeReached), "got: {}", err);
+}