Add bool `assert` syntax

grammar.js

@@ -277,7 +277,7 @@ module.exports = grammar({
       seq(field("label", $.label), field("name", $.identifier)),
     _name_param: ($) => field("name", $.identifier),
     _statement_seq: ($) => repeat1($._statement),
-    _statement: ($) => choice($._expression, $.let, $.let_assert, $.use),
+    _statement: ($) => choice($._expression, $.let, $.let_assert, $.use, $.assert),
     _expression: ($) => choice($._expression_unit, $.binary_expression),
     binary_expression: ($) =>
       choice(
@@ -337,7 +337,6 @@ module.exports = grammar({
         $.anonymous_function,
         $.block,
         $.case,
-        $.assert,
         $.boolean_negation,
         $.integer_negation,
         $.record_update,
@@ -491,6 +490,12 @@ module.exports = grammar({
         $._assignment,
         optional(seq("as", field("message", $._expression)))
       ),
+    assert: ($) =>
+      seq(
+        "assert",
+        field("value", $._expression),
+        optional(seq("as", field("message", $._expression)))
+      ),
     let: ($) => seq("let", $._assignment),
     use: ($) =>
       seq(
@@ -501,7 +506,6 @@ module.exports = grammar({
       ),
     use_assignments: ($) => series_of($.use_assignment, ","),
     use_assignment: ($) => seq($._pattern, optional($._type_annotation)),
-    assert: ($) => seq("assert", $._assignment),
     boolean_negation: ($) => seq("!", $._expression_unit),
     integer_negation: ($) => seq("-", $._expression_unit),
     _assignment: ($) =>

test/corpus/functions.txt

@@ -288,14 +288,15 @@ fn assignment() {
   let y = x
   let #(x, _) = #(1, 2)
 }
-fn assertations() {
-  assert Ok(a) = Ok(1)
-  assert x = {
-    1 + 1
-    "Hello, World!"
-  }
-  assert y = x
-  assert #(x, _) = #(1, 2)
+fn assertions() {
+  assert True && False
+  assert add(1, 2) == 3
+  assert !some_value
+  assert {
+    10
+    11
+  } != 10
+  assert result.is_ok(Ok(10))
 }
 fn update(x) {
   Cat(..x, name: "Nubi", cuteness: 1000 + 1001)
@@ -557,34 +558,42 @@ fn field_access(x) {
     parameters: (function_parameters)
     body: (block
       (assert
-        pattern: (record_pattern
-          name: (constructor_name)
-          arguments: (record_pattern_arguments
-            (record_pattern_argument
-              pattern: (identifier))))
-        value: (record
-          name: (constructor_name)
+        value: (binary_expression
+          left: (record
+            name: (constructor_name))
+          right: (record
+            name: (constructor_name))))
+      (assert
+        value: (binary_expression
+          left: (function_call
+            function: (identifier)
             arguments: (arguments
               (argument
-              value: (integer)))))
-      (assert
-        pattern: (identifier)
-        value: (block
-          (binary_expression
-            left: (integer)
-            right: (integer))
-          (string
-            (quoted_content))))
+                value: (integer))
+              (argument
+                value: (integer))))
+          right: (integer)))
       (assert
-        pattern: (identifier)
-        value: (identifier))
+        value: (boolean_negation
+          (identifier)))
       (assert
-        pattern: (tuple_pattern
-          (identifier)
-          (discard))
-        value: (tuple
+        value: (binary_expression
+          left: (block
             (integer)
-          (integer)))))
+            (integer))
+          right: (integer)))
+      (assert
+        value: (function_call
+          function: (field_access
+            record: (identifier)
+            field: (label))
+          arguments: (arguments
+            (argument
+              value: (record
+                name: (constructor_name)
+                arguments: (arguments
+                  (argument
+                    value: (integer))))))))))
   (function
     name: (identifier)
     parameters: (function_parameters

test/highlight/functions.gleam

@@ -115,6 +115,12 @@ fn let_assert_test() {
   //  ^ keyword
 }
 
+fn assert_test() {
+  assert x == add(1, 4)
+  // <- keyword
+  //          ^ function
+}
+
 fn punned_call_arg_test() {
   wibble(arg:, arg2:)
   // ^ function