Add guards to func definitions.

For example:
```trilogy
func check n if n < 5 = ...
func check n if n > 5 = ...
func check n = { assert n == 5 }
```

Author: foxfriends

TODO.md

@@ -12,7 +12,6 @@
     * Type-agnostic global functions (similar to core, but safe)
     * Consistent interfaces to individual core standard modules
     * Maybe adjust naming and organization of `core.c`, which is kind of scary conflictable
-* Guards on `func`
 * Improve error messages:
     * Eliminate places where panics are visible to the end user; should be covered by `yield`/`end` (rewrite spec I guess)
     * Review error handling in scanner/parser/IR, so all are nicely reported; maybe reimplement this using trait objects so it's not so spread out

testsuite/func-guards/main.tri

@@ -0,0 +1,7 @@
+func check n if n < 5 = false
+func check n = n == 5
+
+proc main!() {
+  assert check 5
+  assert check 5
+}

trilogy-ir/src/ir/function.rs

@@ -8,6 +8,7 @@ pub struct Function {
     pub span: Span,
     pub head_span: Span,
     pub parameters: Vec<Expression>,
+    pub guard: Option<Expression>,
     pub body: Expression,
 }
 
@@ -22,13 +23,18 @@ impl Function {
             .into_iter()
             .map(|param| Expression::convert_pattern(converter, param))
             .collect();
+        let guard = ast
+            .head
+            .guard
+            .map(|guard| Expression::convert(converter, guard.expression));
         let body = Expression::builtin(span, Builtin::Return)
             .apply_to(span, Expression::convert(converter, ast.body));
         converter.pop_scope();
         Self {
             span,
             head_span,
             parameters,
+            guard,
             body,
         }
     }
@@ -48,6 +54,7 @@ impl Function {
             head_span: ast.r#fn.span.union(ast.dot.span),
             span,
             parameters,
+            guard: None,
             body,
         }
     }

trilogy-ir/src/ir/handler.rs

@@ -7,7 +7,7 @@ use trilogy_parser::{Spanned, syntax};
 pub struct Handler {
     pub span: Span,
     pub pattern: Expression,
-    pub guard: Expression,
+    pub guard: Option<Expression>,
     pub body: Expression,
 }
 
@@ -60,10 +60,7 @@ impl Handler {
                 let pattern = Expression::convert_pattern(converter, handler.pattern);
                 let pattern =
                     Expression::reference(pattern.span, effect.clone()).and(pattern.span, pattern);
-                let guard = handler
-                    .guard
-                    .map(|ast| Expression::convert(converter, ast))
-                    .unwrap_or_else(|| Expression::boolean(span, true));
+                let guard = handler.guard.map(|ast| Expression::convert(converter, ast));
                 converter.scope.set_allow_resume_cancel(true);
                 let body = Self::convert_strategy(converter, handler.strategy, effect);
                 Self {
@@ -78,13 +75,12 @@ impl Handler {
                 let else_span = handler.else_token().span;
                 let effect = Identifier::temporary(converter, else_span);
                 let pattern = Expression::reference(else_span, effect.clone());
-                let guard = Expression::boolean(else_span, true);
                 converter.scope.set_allow_resume_cancel(true);
                 let body = Self::convert_strategy(converter, handler.strategy, effect);
                 Self {
                     span,
                     pattern,
-                    guard,
+                    guard: None,
                     body,
                 }
             }

trilogy-ir/src/ir/match.rs

@@ -29,21 +29,20 @@ impl Match {
                 let span = ast.r#else.span().union(ast.body.span());
                 converter.push_scope();
                 let pattern = Expression::wildcard(ast.r#else.span);
-                let guard = Expression::boolean(ast.r#else.span, true);
                 let body = Expression::convert(converter, ast.body);
                 converter.pop_scope();
                 cases.push(Case {
                     span,
                     pattern,
-                    guard,
+                    guard: None,
                     body,
                 });
             }
             None => {
                 cases.push(Case {
                     span,
                     pattern: Expression::wildcard(span),
-                    guard: Expression::boolean(span, true),
+                    guard: None,
                     body: Expression::unit(span),
                 });
             }
@@ -67,21 +66,20 @@ impl Match {
                 let span = ast.r#else.span().union(ast.body.span());
                 converter.push_scope();
                 let pattern = Expression::wildcard(ast.r#else.span);
-                let guard = Expression::boolean(ast.r#else.span, true);
                 let body = Expression::convert(converter, ast.body);
                 converter.pop_scope();
                 cases.push(Case {
                     span,
                     pattern,
-                    guard,
+                    guard: None,
                     body,
                 });
             }
             None => {
                 cases.push(Case {
                     span,
                     pattern: Expression::wildcard(span),
-                    guard: Expression::boolean(span, true),
+                    guard: None,
                     body: Expression::end(span),
                 });
             }
@@ -94,7 +92,7 @@ impl Match {
 pub struct Case {
     pub span: Span,
     pub pattern: Expression,
-    pub guard: Expression,
+    pub guard: Option<Expression>,
     pub body: Expression,
 }
 
@@ -109,8 +107,7 @@ impl Case {
             .unwrap_or_else(|| Expression::wildcard(case_span));
         let guard = ast
             .guard
-            .map(|ast| Expression::convert(converter, ast.expression))
-            .unwrap_or_else(|| Expression::boolean(case_span, true));
+            .map(|ast| Expression::convert(converter, ast.expression));
         let body = match ast.body {
             FollowingExpression::Then(_, body) => Expression::convert(converter, body),
             FollowingExpression::Block(body) => Expression::convert_block(converter, body),

trilogy-ir/src/visitor/mod.rs

@@ -298,7 +298,9 @@ impl IrVisitable for Match {
 impl IrVisitable for Case {
     fn visit<V: IrVisitor>(&self, visitor: &mut V) {
         visitor.visit_pattern(&self.pattern);
-        visitor.visit_expression(&self.guard);
+        if let Some(guard) = &self.guard {
+            visitor.visit_expression(guard);
+        }
         visitor.visit_expression(&self.body);
     }
 }
@@ -308,6 +310,9 @@ impl IrVisitable for Function {
         for parameter in &self.parameters {
             visitor.visit_pattern(parameter);
         }
+        if let Some(guard) = &self.guard {
+            visitor.visit_expression(guard);
+        }
         visitor.visit_expression(&self.body);
     }
 }
@@ -333,7 +338,9 @@ impl IrVisitable for Handled {
 impl IrVisitable for Handler {
     fn visit<V: IrVisitor>(&self, visitor: &mut V) {
         visitor.visit_pattern(&self.pattern);
-        visitor.visit_expression(&self.guard);
+        if let Some(guard) = &self.guard {
+            visitor.visit_expression(guard);
+        }
         visitor.visit_expression(&self.body);
     }
 }

trilogy-ir/src/visitor/references.rs

@@ -58,7 +58,9 @@ impl IrVisitor for References {
 
     fn visit_case(&mut self, node: &Case) {
         self.ignore.extend(node.bindings());
-        node.guard.visit(self);
+        if let Some(guard) = &node.guard {
+            guard.visit(self);
+        }
         node.body.visit(self);
     }
 
@@ -79,7 +81,9 @@ impl IrVisitor for References {
 
     fn visit_handler(&mut self, node: &Handler) {
         self.ignore.extend(node.bindings());
-        node.guard.visit(self);
+        if let Some(guard) = &node.guard {
+            guard.visit(self);
+        }
         node.body.visit(self);
     }
 

trilogy-llvm/src/expression/mod.rs

@@ -292,6 +292,12 @@ impl<'ctx> Codegen<'ctx> {
         // The handler works similar to a match expression, but matching against the effect
         // and doing much more control flow work.
         for handler in handlers {
+            if matches!(
+                handler.guard.as_ref().map(|g| &g.value),
+                Some(Value::Boolean(false))
+            ) {
+                continue;
+            }
             let next_case_function = self.add_continuation("");
             let (go_to_next_case, next_case_cp) =
                 self.capture_current_continuation(next_case_function, "when.next");
@@ -301,30 +307,34 @@ impl<'ctx> Codegen<'ctx> {
             {
                 break;
             }
-            let Some(guard_bool) = self.compile_expression(&handler.guard, "when.guard") else {
-                self.become_continuation_point(next_case_cp);
-                self.begin_next_function(next_case_function);
-                continue;
-            };
-            let guard_flag = self.trilogy_boolean_untag(guard_bool, "");
-            // NOTE: bool doesn't really need to be destroyed... but do it anyway
-            self.trilogy_value_destroy(guard_bool);
-            let body_block = self.context.append_basic_block(self.get_function(), "body");
-            let next_block = self.context.append_basic_block(self.get_function(), "next");
-            let body_cp = self.branch_continuation_point();
-            self.builder
-                .build_conditional_branch(guard_flag, body_block, next_block)
-                .unwrap();
-            let snapshot = self.snapshot_function_context();
-
-            self.builder.position_at_end(next_block);
-            let go_next = self.use_temporary_clone(go_to_next_case).unwrap();
-            self.void_call_continuation(go_next);
-
-            self.builder.position_at_end(body_block);
-            self.destroy_owned_temporary(go_to_next_case);
-            self.restore_function_context(snapshot);
-            self.become_continuation_point(body_cp);
+            if let Some(guard) = &handler.guard
+                && !matches!(guard.value, Value::Boolean(true))
+            {
+                let Some(guard_bool) = self.compile_expression(guard, "when.guard") else {
+                    self.become_continuation_point(next_case_cp);
+                    self.begin_next_function(next_case_function);
+                    continue;
+                };
+                let guard_flag = self.trilogy_boolean_untag(guard_bool, "");
+                // NOTE: bool doesn't really need to be destroyed... but do it anyway
+                self.trilogy_value_destroy(guard_bool);
+                let body_block = self.context.append_basic_block(self.get_function(), "body");
+                let next_block = self.context.append_basic_block(self.get_function(), "next");
+                let body_cp = self.branch_continuation_point();
+                self.builder
+                    .build_conditional_branch(guard_flag, body_block, next_block)
+                    .unwrap();
+                let snapshot = self.snapshot_function_context();
+
+                self.builder.position_at_end(next_block);
+                let go_next = self.use_temporary_clone(go_to_next_case).unwrap();
+                self.void_call_continuation(go_next);
+
+                self.builder.position_at_end(body_block);
+                self.destroy_owned_temporary(go_to_next_case);
+                self.restore_function_context(snapshot);
+                self.become_continuation_point(body_cp);
+            }
             self.push_handler_scope(resume);
             if let Some(result) = self.compile_expression(&handler.body, "handler_result") {
                 // If a handler runs off, it ends. Most handlers should choose to explicitly cancel
@@ -545,7 +555,10 @@ impl<'ctx> Codegen<'ctx> {
         for case in &expr.cases {
             // An unmatchable case can be skipped; rare this would occur, but easy to handle
             // since we're handling true specially anyway
-            if matches!(case.guard.value, Value::Boolean(false)) {
+            if matches!(
+                case.guard.as_ref().map(|g| &g.value),
+                Some(Value::Boolean(false))
+            ) {
                 continue;
             }
 
@@ -554,8 +567,10 @@ impl<'ctx> Codegen<'ctx> {
                 self.capture_current_continuation(next_case_function, "match.next");
             self.compile_pattern_match(&case.pattern, discriminant, go_to_next_case)?;
 
-            if !matches!(case.guard.value, Value::Boolean(true)) {
-                let Some(guard_bool) = self.compile_expression(&case.guard, "match.guard") else {
+            if let Some(guard) = &case.guard
+                && !matches!(guard.value, Value::Boolean(true))
+            {
+                let Some(guard_bool) = self.compile_expression(guard, "match.guard") else {
                     self.become_continuation_point(next_case_cp);
                     self.begin_next_function(next_case_function);
                     continue;

trilogy-llvm/src/function.rs

@@ -2,7 +2,10 @@ use crate::Codegen;
 use inkwell::values::{BasicValue, FunctionValue};
 use source_span::Span;
 use std::borrow::Borrow;
-use trilogy_ir::{Id, ir};
+use trilogy_ir::{
+    Id,
+    ir::{self, Expression, Value},
+};
 
 impl<'ctx> Codegen<'ctx> {
     fn write_function_accessor(
@@ -72,6 +75,13 @@ impl<'ctx> Codegen<'ctx> {
         'outer: for (i, overload) in overloads.iter().enumerate() {
             let overload = overload.borrow();
             assert_eq!(overload.parameters.len(), arity);
+            if matches!(
+                overload.guard.as_ref().map(|g| &g.value),
+                Some(Value::Boolean(false))
+            ) {
+                continue;
+            }
+
             self.set_span(overload.head_span);
 
             let next_overload_function = self.add_continuation(if i == overloads.len() - 1 {
@@ -90,6 +100,32 @@ impl<'ctx> Codegen<'ctx> {
                     break 'outer;
                 }
             }
+
+            if let Some(guard) = &overload.guard
+                && !matches!(guard.value, Value::Boolean(true))
+            {
+                let Some(guard_bool) = self.compile_expression(guard, "match.guard") else {
+                    self.become_continuation_point(next_overload_cp);
+                    self.begin_next_function(next_overload_function);
+                    continue;
+                };
+                let guard_flag = self.trilogy_boolean_untag(guard_bool, "");
+                self.trilogy_value_destroy(guard_bool); // NOTE: bool doesn't really need to be destroyed... but do it anyway
+                let next_block = self.context.append_basic_block(self.get_function(), "next");
+                let body_block = self.context.append_basic_block(self.get_function(), "body");
+                let body_cp = self.branch_continuation_point();
+                self.builder
+                    .build_conditional_branch(guard_flag, body_block, next_block)
+                    .unwrap();
+
+                self.builder.position_at_end(next_block);
+                let go_next = self.use_temporary_clone(go_to_next_overload).unwrap();
+                self.void_call_continuation(go_next);
+
+                self.builder.position_at_end(body_block);
+                self.become_continuation_point(body_cp);
+            }
+
             self.destroy_owned_temporary(go_to_next_overload);
 
             if let Some(value) = self.compile_expression(&overload.body, "") {