vine: allow returns with no expression

tests/programs/no_return.vi

@@ -0,0 +1,8 @@
+
+use std::io::println;
+
+fn main(io) {
+  io.println("We should see this");
+  return;
+  io.println("But not this");
+}

tests/snaps/vine/no_return/compiled.iv

@@ -0,0 +1,31 @@
+
+::main { ::no_return::main }
+
+::no_return::main {
+  fn(n0 _)
+  ::std::io::println = fn(ref(n0 _) fn(tup(18 tup(tup(87 tup(101 tup(32 tup(115 tup(104 tup(111 tup(117 tup(108 tup(100 tup(32 tup(115 tup(101 tup(101 tup(32 tup(116 tup(104 tup(105 tup(115 n1)))))))))))))))))) n1)) _))
+}
+
+::std::io::println {
+  fn(ref(n0 n3) fn(n1 _))
+  ::std::io::print = fn(ref(n0 n2) fn(n1 _))
+  ::std::io::print_char = fn(ref(n2 n3) fn(10 _))
+}
+
+::std::io::print {
+  fn(ref(n0 n1) fn(tup(n2 tup(n3 _)) _))
+  ::std::io::print::1 = x(n0 x(n1 x(n2 n3)))
+}
+
+::std::io::print::1 { x(n0 x(n1 x(dup12(?(::std::io::print::3 ::std::io::print::2 x(n0 x(n1 x(n3 n2)))) n3) n2))) }
+
+::std::io::print::2 {
+  x(n1 x(n3 x(@sub(1 n4) tup(n0 n5))))
+  ::std::io::print_char = fn(ref(n1 n2) fn(n0 _))
+  ::std::io::print::1 = x(n2 x(n3 x(n4 n5)))
+}
+
+::std::io::print::3 { x(n0 x(n0 _)) }
+
+::std::io::print_char { fn(ref(@io_print_char(char io) io) fn(char _)) }
+

tests/snaps/vine/no_return/output.txt

@@ -0,0 +1 @@
+We should see this

tests/snaps/vine/no_return/stats.txt

@@ -0,0 +1,15 @@
+
+Interactions
+  Total                    397
+  Annihilate               215
+  Commute                    0
+  Copy                      21
+  Erase                     44
+  Expand                    61
+  Call                      37
+  Branch                    19
+
+Memory
+  Heap                     592 B
+  Allocated              8_112 B
+  Freed                  8_112 B

tests/tests.rs

@@ -47,6 +47,7 @@ fn tests(t: &mut DynTester) {
     test_vi(t, "tests/programs/loop_vi_loop.vi", b"", ".txt");
     test_vi(t, "tests/programs/maybe_set.vi", b"", ".txt");
     test_vi(t, "tests/programs/move_it_move_it.vi", b"", ".txt");
+    test_vi(t, "tests/programs/no_return.vi", b"", ".txt");
     test_vi(t, "tests/programs/option_party.vi", b"", ".txt");
     test_vi(t, "tests/programs/pretty_div.vi", b"", ".txt");
     test_vi(t, "tests/programs/so_random.vi", b"", ".txt");

vine/src/ast.rs

@@ -153,7 +153,7 @@ pub enum ExprKind {
   #[class(value)]
   Fn(Vec<Pat>, B<Expr>),
   #[class(value)]
-  Return(B<Expr>),
+  Return(Option<B<Expr>>),
   #[class(value)]
   Break,
   #[class(value)]

vine/src/compile/build_stages.rs

@@ -132,7 +132,7 @@ impl Compiler<'_> {
       ExprKind::Loop(body) => self.lower_loop(body),
       ExprKind::While(cond, body) => self.lower_while(cond, body),
       ExprKind::If(cond, then, els) => self.lower_if(cond, then, els),
-      ExprKind::Return(r) => self.lower_return(r),
+      ExprKind::Return(r) => self.lower_return(r.as_deref()),
       ExprKind::Break => self.lower_break(),
       ExprKind::Continue => self.lower_continue(),
 

vine/src/compile/build_stages/control_flow.rs

@@ -22,10 +22,13 @@ impl Compiler<'_> {
     func.1
   }
 
-  pub(super) fn lower_return(&mut self, r: &Expr) -> Port {
-    let r = self.lower_expr_value(r);
+  pub(super) fn lower_return(&mut self, r: Option<&Expr>) -> Port {
     let ret = self.return_target.unwrap();
-    self.set_local_to(ret.0, r);
+    if let Some(r) = r {
+      let r = self.lower_expr_value(r);
+      self.set_local_to(ret.0, r);
+    }
+
     self.diverge(ret.1);
     Port::Erase
   }

vine/src/parser.rs

@@ -248,7 +248,11 @@ impl<'ctx, 'src> VineParser<'ctx, 'src> {
 
   fn _parse_expr_prefix(&mut self, span: usize) -> Parse<'src, ExprKind> {
     if self.eat(Token::Return)? {
-      return Ok(ExprKind::Return(Box::new(self.parse_expr_bp(BP::ControlFlow)?)));
+      if self.check(Token::Semi) {
+        return Ok(ExprKind::Return(None));
+      }
+
+      return Ok(ExprKind::Return(Some(Box::new(self.parse_expr_bp(BP::ControlFlow)?))));
     }
     if self.eat(Token::Break)? {
       return Ok(ExprKind::Break);

vine/src/visit.rs

@@ -50,14 +50,15 @@ pub trait VisitMut<'a> {
       | ExprKind::Error(_)
       | ExprKind::CopyLocal(_)
       | ExprKind::MoveLocal(_)
+      | ExprKind::Return(None)
       | ExprKind::SetLocal(_) => {}
       ExprKind::Ref(a)
       | ExprKind::Deref(a)
       | ExprKind::Move(a)
       | ExprKind::Field(a, _)
       | ExprKind::Neg(a)
       | ExprKind::Not(a)
-      | ExprKind::Return(a)
+      | ExprKind::Return(Some(a))
       | ExprKind::Inverse(a)
       | ExprKind::Copy(a)
       | ExprKind::Set(a)