Fix unbalanced if as expression: always yields a value (unit when false)

Previously `if cond { val }` without an else branch was stack-neutral
(net-zero), which meant `return if cond { val }` would pop the wrong
stack slot. The fix has two parts:

1. `compile_if` (no-else): emit a Jump/else-path that pushes unit so
   the expression always leaves exactly one value on the stack.

2. Parser `block()`: wrap non-last, non-Statement block items in
   `to_statement()` so `Expression::Statement` handles value cleanup
   as designed, rather than leaking the if's result onto the stack.

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

Author: timfennis

compiler_tests/tests/compiler.rs

@@ -27,16 +27,27 @@ fn compile_with_analysis(input: &str) -> Vec<OpCode> {
 // if true { 1 }
 //
 // 0: Constant(0)      push `true`
-// 1: JumpIfFalse(2)   if false, skip true-branch and land on final Pop
+// 1: JumpIfFalse(3)   if false, jump to else path (index 5)
 // 2: Pop              pop condition (true path)
 // 3: Constant(1)      push `1`
-// 4: Pop              pop condition (false path, jumped here)
-// 5: Halt
+// 4: Jump(2)          skip else path (jump to Halt at index 7)
+// 5: Pop              pop condition (false path, jumped here)
+// 6: Constant(2)      push `None` (unit, no else branch)
+// 7: Halt
 #[test]
 fn test_if_without_else() {
     assert_eq!(
         compile("if true { 1 }"),
-        [Constant(0), JumpIfFalse(2), Pop, Constant(1), Pop, Halt]
+        [
+            Constant(0),
+            JumpIfFalse(3),
+            Pop,
+            Constant(1),
+            Jump(2),
+            Pop,
+            Constant(2),
+            Halt
+        ]
     );
 }
 

ndc_parser/src/parser.rs

@@ -1225,6 +1225,21 @@ impl Parser {
             }
         };
 
+        // Non-last items in a block are in statement position: wrap bare expressions
+        // (e.g. `if` without else) in Statement so the compiler discards their values.
+        let last = statements.len().saturating_sub(1);
+        let statements = statements
+            .into_iter()
+            .enumerate()
+            .map(|(i, stmt)| {
+                if i < last && !matches!(stmt.expression, Expression::Statement(_)) {
+                    stmt.to_statement()
+                } else {
+                    stmt
+                }
+            })
+            .collect();
+
         Ok(Expression::Block { statements }.to_location(left_curly_span.merge(loop_span)))
     }
 

ndc_vm/src/compiler.rs

@@ -511,8 +511,12 @@ impl Compiler {
             self.compile_expr(on_false)?;
             self.chunk.patch_jump(jump_to_end);
         } else {
+            let jump_to_end = self.chunk.write(OpCode::Jump(0), Span::new(0, 0));
             self.chunk.patch_jump(conditional_jump_idx);
             self.chunk.write(OpCode::Pop, Span::new(0, 0));
+            let idx = self.chunk.add_constant(Value::unit());
+            self.chunk.write(OpCode::Constant(idx), Span::new(0, 0));
+            self.chunk.patch_jump(jump_to_end);
         }
 
         Ok(())
@@ -898,7 +902,6 @@ fn produces_value(expr: &Expression) -> bool {
             ..
         }
         | Expression::While { .. }
-        | Expression::If { on_false: None, .. }
         | Expression::Break
         | Expression::Continue
         | Expression::Return { .. } => false,

tests/programs/998_not_desired/return_unbalanced_if.ndc

@@ -1,3 +1,4 @@
+// vm-ready
 // NOTE: this is definitely a weird one that should probably generate a type error in the future
 fn is_positive(n) {
     return if n >= 0 {