Implement bool assert

.github/workflows/ci.yaml

@@ -498,3 +498,7 @@ jobs:
       - name: test/unicode_path
         run: make
         working-directory: ./test/unicode_path ⭐
+
+      - name: test/assert
+        run: make test-all
+        working-directory: ./test/assert

CHANGELOG.md

@@ -98,6 +98,32 @@
 
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
+- You can now use the `assert` keyword by itself to test a boolean expression.
+  If the expression evaluates to `False` at runtime, the `assert` statement
+  will cause the program to panic, with information about the expression that
+  was asserted.
+
+  For example:
+
+  ```gleam
+  pub fn ok_error_test() {
+    assert result.is_ok(Ok(10))
+    assert result.is_error(Error("Some error"))
+    assert Ok(1) != Error(1)
+    assert result.is_error(Ok(42)) // panic: Assertion failed
+  }
+  ```
+
+  A custom panic message can also be provided in order to add extra information:
+
+  ```gleam
+  pub fn identity_test() {
+    assert function.identity(True) as "Identity of True should never be False"
+  }
+  ```
+
+  ([Surya Rose](https://github.com/GearsDatapacks))
+
 ### Build tool
 
 - The build tool now supports placing modules in a directory called `dev`,

compiler-cli/src/new.rs

@@ -132,16 +132,17 @@ pub fn main() -> Nil {{
 
             Self::TestModule => Some(
                 r#"import gleeunit
-import gleeunit/should
 
 pub fn main() -> Nil {
   gleeunit.main()
 }
 
 // gleeunit test functions end in `_test`
 pub fn hello_world_test() {
-  1
-  |> should.equal(1)
+  let name = "Joe"
+  let greeting = "Hello, " <> name <> "!"
+
+  assert greeting == "Hello, Joe!"
 }
 "#
                 .into(),

compiler-cli/src/new/snapshots/gleam_cli__new__tests__new_with_default_template@test__my_project_test.gleam.snap

@@ -1,16 +1,19 @@
 ---
 source: compiler-cli/src/new/tests.rs
+assertion_line: 56
 expression: "crate::fs::read(Utf8PathBuf::from_path_buf(file_path.to_path_buf()).expect(\"Non Utf8 Path\"),).unwrap()"
+snapshot_kind: text
 ---
 import gleeunit
-import gleeunit/should
 
 pub fn main() -> Nil {
   gleeunit.main()
 }
 
 // gleeunit test functions end in `_test`
 pub fn hello_world_test() {
-  1
-  |> should.equal(1)
+  let name = "Joe"
+  let greeting = "Hello, " <> name <> "!"
+
+  assert greeting == "Hello, Joe!"
 }

compiler-cli/src/new/snapshots/gleam_cli__new__tests__new_with_javascript_template@test__my_project_test.gleam.snap

@@ -1,16 +1,19 @@
 ---
 source: compiler-cli/src/new/tests.rs
+assertion_line: 86
 expression: "crate::fs::read(Utf8PathBuf::from_path_buf(file_path.to_path_buf()).expect(\"Non Utf8 Path\"),).unwrap()"
+snapshot_kind: text
 ---
 import gleeunit
-import gleeunit/should
 
 pub fn main() -> Nil {
   gleeunit.main()
 }
 
 // gleeunit test functions end in `_test`
 pub fn hello_world_test() {
-  1
-  |> should.equal(1)
+  let name = "Joe"
+  let greeting = "Hello, " <> name <> "!"
+
+  assert greeting == "Hello, Joe!"
 }

compiler-core/src/ast.rs

@@ -19,7 +19,7 @@ use crate::type_::expression::Implementations;
 use crate::type_::printer::Names;
 use crate::type_::{
     self, Deprecation, ModuleValueConstructor, PatternConstructor, Type, TypedCallArg,
-    ValueConstructor,
+    ValueConstructor, nil,
 };
 use std::sync::Arc;
 
@@ -2673,6 +2673,8 @@ pub enum Statement<TypeT, ExpressionT> {
     Assignment(Assignment<TypeT, ExpressionT>),
     /// A `use` expression.
     Use(Use<TypeT, ExpressionT>),
+    /// A bool assertion.
+    Assert(Assert<ExpressionT>),
 }
 
 pub type UntypedUse = Use<(), UntypedExpr>;
@@ -2782,6 +2784,7 @@ impl UntypedStatement {
             Statement::Expression(expression) => expression.location(),
             Statement::Assignment(assignment) => assignment.location,
             Statement::Use(use_) => use_.location,
+            Statement::Assert(assert) => assert.location,
         }
     }
 
@@ -2790,13 +2793,14 @@ impl UntypedStatement {
             Statement::Expression(expression) => expression.start_byte_index(),
             Statement::Assignment(assignment) => assignment.location.start,
             Statement::Use(use_) => use_.location.start,
+            Statement::Assert(assert) => assert.location.start,
         }
     }
 
     pub fn is_placeholder(&self) -> bool {
         match self {
             Statement::Expression(expression) => expression.is_placeholder(),
-            Statement::Assignment(_) | Statement::Use(_) => false,
+            Statement::Assignment(_) | Statement::Use(_) | Statement::Assert(_) => false,
         }
     }
 }
@@ -2807,6 +2811,7 @@ impl TypedStatement {
             Statement::Expression(e) => e.is_println(),
             Statement::Assignment(_) => false,
             Statement::Use(_) => false,
+            Statement::Assert(_) => false,
         }
     }
 
@@ -2815,6 +2820,7 @@ impl TypedStatement {
             Statement::Expression(expression) => expression.location(),
             Statement::Assignment(assignment) => assignment.location,
             Statement::Use(use_) => use_.location,
+            Statement::Assert(assert) => assert.location,
         }
     }
 
@@ -2826,14 +2832,16 @@ impl TypedStatement {
             Statement::Expression(expression) => expression.last_location(),
             Statement::Assignment(assignment) => assignment.value.last_location(),
             Statement::Use(use_) => use_.call.last_location(),
+            Statement::Assert(assert) => assert.value.last_location(),
         }
     }
 
     pub fn type_(&self) -> Arc<Type> {
         match self {
             Statement::Expression(expression) => expression.type_(),
             Statement::Assignment(assignment) => assignment.type_(),
-            Statement::Use(_use) => _use.call.type_(),
+            Statement::Use(use_) => use_.call.type_(),
+            Statement::Assert(_) => nil(),
         }
     }
 
@@ -2842,6 +2850,7 @@ impl TypedStatement {
             Statement::Expression(expression) => expression.definition_location(),
             Statement::Assignment(_) => None,
             Statement::Use(use_) => use_.call.definition_location(),
+            Statement::Assert(_) => None,
         }
     }
 
@@ -2856,6 +2865,13 @@ impl TypedStatement {
                     None
                 }
             }),
+            Statement::Assert(assert) => assert.find_node(byte_index).or_else(|| {
+                if assert.location.contains(byte_index) {
+                    Some(Located::Statement(self))
+                } else {
+                    None
+                }
+            }),
         }
     }
 
@@ -2872,6 +2888,13 @@ impl TypedStatement {
                     }
                 })
             }
+            Statement::Assert(assert) => assert.value.find_statement(byte_index).or_else(|| {
+                if assert.location.contains(byte_index) {
+                    Some(self)
+                } else {
+                    None
+                }
+            }),
         }
     }
 
@@ -2880,6 +2903,7 @@ impl TypedStatement {
             Statement::Expression(expression) => expression.type_defining_location(),
             Statement::Assignment(assignment) => assignment.location,
             Statement::Use(use_) => use_.location,
+            Statement::Assert(assert) => assert.location,
         }
     }
 
@@ -2892,6 +2916,8 @@ impl TypedStatement {
                 !assignment.kind.is_assert() && assignment.value.is_pure_value_constructor()
             }
             Statement::Use(Use { call, .. }) => call.is_pure_value_constructor(),
+            // Assert statements by definition are not pure
+            Statement::Assert(_) => false,
         }
     }
 }
@@ -2925,6 +2951,30 @@ impl TypedAssignment {
     }
 }
 
+pub type TypedAssert = Assert<TypedExpr>;
+pub type UntypedAssert = Assert<UntypedExpr>;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Assert<Expression> {
+    pub location: SrcSpan,
+    pub value: Expression,
+    pub message: Option<Expression>,
+}
+
+impl TypedAssert {
+    pub fn find_node(&self, byte_index: u32) -> Option<Located<'_>> {
+        if let Some(found) = self.value.find_node(byte_index) {
+            return Some(found);
+        }
+        if let Some(message) = &self.message {
+            if let Some(found) = message.find_node(byte_index) {
+                return Some(found);
+            }
+        }
+        None
+    }
+}
+
 /// A pipeline is desugared to a series of assignments:
 ///
 /// ```gleam

compiler-core/src/ast/tests.rs

@@ -59,7 +59,7 @@ fn compile_module(src: &str) -> TypedModule {
 fn get_bare_expression(statement: &TypedStatement) -> &TypedExpr {
     match statement {
         Statement::Expression(expression) => expression,
-        Statement::Use(_) | Statement::Assignment(_) => {
+        Statement::Use(_) | Statement::Assignment(_) | Statement::Assert(_) => {
             panic!("Expected expression, got {statement:?}")
         }
     }

compiler-core/src/ast/typed.rs

@@ -669,10 +669,43 @@ impl TypedExpr {
             | Self::Tuple { .. }
             | Self::String { .. }
             | Self::BitArray { .. } => true,
+
+            // Calls are literals if they are records and all the arguemnts are also literals.
+            Self::Call { fun, args, .. } => {
+                fun.is_record_constructor()
+                    && args.iter().all(|argument| argument.value.is_literal())
+            }
+
+            // Variables are literals if they are record constructors that take no arguments.
+            Self::Var {
+                constructor:
+                    ValueConstructor {
+                        variant: ValueConstructorVariant::Record { arity: 0, .. },
+                        ..
+                    },
+                ..
+            } => true,
+
             _ => false,
         }
     }
 
+    pub fn is_known_value(&self) -> bool {
+        match self {
+            Self::Int { .. }
+            | Self::List { .. }
+            | Self::Float { .. }
+            | Self::Tuple { .. }
+            | Self::String { .. }
+            | Self::BitArray { .. } => true,
+            TypedExpr::BinOp { left, right, .. } => left.is_known_value() && right.is_known_value(),
+            TypedExpr::NegateBool { value, .. } | TypedExpr::NegateInt { value, .. } => {
+                value.is_known_value()
+            }
+            expr => expr.is_record_builder(),
+        }
+    }
+
     pub fn is_literal_string(&self) -> bool {
         match self {
             Self::String { .. } => true,
@@ -816,6 +849,21 @@ impl TypedExpr {
         }
     }
 
+    #[must_use]
+    pub fn is_record_constructor(&self) -> bool {
+        match self {
+            TypedExpr::Var {
+                constructor:
+                    ValueConstructor {
+                        variant: ValueConstructorVariant::Record { .. },
+                        ..
+                    },
+                ..
+            } => true,
+            _ => false,
+        }
+    }
+
     #[must_use]
     pub fn is_record_builder(&self) -> bool {
         match self {
@@ -829,6 +877,7 @@ impl TypedExpr {
         }
     }
 
+    #[must_use]
     /// If `self` is a record constructor, returns the nuber of arguments it
     /// needs to be called. Otherwise, returns `None`.
     ///

compiler-core/src/ast/visit.rs

@@ -55,7 +55,7 @@ use crate::type_::Type;
 
 use super::{
     AssignName, BinOp, BitArrayOption, CallArg, Definition, Pattern, PipelineAssignmentKind,
-    SrcSpan, Statement, TodoKind, TypeAst, TypedArg, TypedAssignment, TypedClause,
+    SrcSpan, Statement, TodoKind, TypeAst, TypedArg, TypedAssert, TypedAssignment, TypedClause,
     TypedClauseGuard, TypedConstant, TypedCustomType, TypedDefinition, TypedExpr,
     TypedExprBitArraySegment, TypedFunction, TypedModule, TypedModuleConstant, TypedPattern,
     TypedPatternBitArraySegment, TypedPipelineAssignment, TypedStatement, TypedUse,
@@ -330,6 +330,10 @@ pub trait Visit<'ast> {
         visit_typed_use(self, use_);
     }
 
+    fn visit_typed_assert(&mut self, assert: &'ast TypedAssert) {
+        visit_typed_assert(self, assert);
+    }
+
     fn visit_typed_pipeline_assignment(&mut self, assignment: &'ast TypedPipelineAssignment) {
         visit_typed_pipeline_assignment(self, assignment);
     }
@@ -1154,6 +1158,7 @@ where
         Statement::Expression(expr) => v.visit_typed_expr(expr),
         Statement::Assignment(assignment) => v.visit_typed_assignment(assignment),
         Statement::Use(use_) => v.visit_typed_use(use_),
+        Statement::Assert(assert) => v.visit_typed_assert(assert),
     }
 }
 
@@ -1173,6 +1178,16 @@ where
     // TODO: We should also visit the typed patterns!!
 }
 
+pub fn visit_typed_assert<'a, V>(v: &mut V, assert: &'a TypedAssert)
+where
+    V: Visit<'a> + ?Sized,
+{
+    v.visit_typed_expr(&assert.value);
+    if let Some(message) = &assert.message {
+        v.visit_typed_expr(message);
+    }
+}
+
 pub fn visit_typed_call_arg<'a, V>(v: &mut V, arg: &'a TypedCallArg)
 where
     V: Visit<'a> + ?Sized,