Change assert from a statement to an expression.

Closes #77.

Author: alexrp

doc/language/expressions.md

@@ -9,6 +9,7 @@ primary-expression ::= parenthesized-expression |
                        block-expression |
                        this-expression |
                        meta-expression |
+                       assert-expression |
                        identifier-expression |
                        literal-expression |
                        module-expression |

…/language/statements/assert-statement.md …anguage/expressions/assert-expression.mddoc/language/statements/assert-statement.md renamed to doc/language/expressions/assert-expression.md doc/language/statements/assert-statement.md renamed to doc/language/expressions/assert-expression.md

@@ -1,18 +1,20 @@
-# Assertion Statement
+# Assert Expression
 
 ```ebnf
-assert-statement ::= 'assert' expression
+assert-expression ::= 'assert' expression
 ```
 
 Evaluates [`expression`](../expressions.md) (the *condition*). If the result
 does not test as [truthy](../expressions/control/if-expression.md#truthiness), a
-panic occurs. An `assert` statement is always executed; it is not conditional on
-build flags or similar.
+panic occurs. An `assert` expression is always executed; it is not conditional
+on build flags or similar.
 
 <!-- TODO: Link to panic definition. -->
 
-An `assert` statement is typically used in a
+An `assert` expression is typically used in a
 [`test` declaration](../declarations/test-declaration.md) to verify the outcome
 of a unit test, but it can also be used in regular code. The runtime system is
 allowed to optimize with the assumption that *condition* holds after the
-`assert` statement.
+`assert` expression.
+
+The result of an `assert` expression is the value of the *condition*.

doc/language/statements.md

@@ -3,6 +3,5 @@
 ```ebnf
 statement ::= attribute* (let-statement |
                           defer-statement |
-                          assert-statement |
                           expression-statement) ';'
 ```

doc/toc.md

@@ -59,7 +59,6 @@
 * [Statements](language/statements.md)
     * [Let Statement](language/statements/let-statement.md)
     * [Defer Statement](language/statements/defer-statement.md)
-    * [Assert Statement](language/statements/assert-statement.md)
     * [Expression Statement](language/statements/expression-statement.md)
 * [Expressions](language/expressions.md)
     * Value Expressions
@@ -96,6 +95,7 @@
     * [Block Expression](language/expressions/block-expression.md)
     * [This Expression](language/expressions/this-expression.md)
     * [Meta Expression](language/expressions/meta-expression.md)
+    * [Assert Expression](language/expressions/assert-expression.md)
     * [Identifier Expression](language/expressions/identifier-expression.md)
     * [Assignment Expression](language/expressions/assignment-expression.md)
     * [Field Expression](language/expressions/field-expression.md)

src/language/core/Quality/Passes/TestWithoutAssertPass.cs

@@ -15,8 +15,8 @@ protected internal override void Run(LintPassContext context)
     {
         foreach (var decl in Unsafe.As<ModuleDocumentSemantics>(context.Root).Declarations)
             if (decl is TestDeclarationSemantics { Syntax.NameToken: { IsMissing: false } name } test &&
-                test.Body.Descendants().All(static node => node is not AssertStatementSemantics))
+                test.Body.Descendants().All(static node => node is not AssertExpressionSemantics))
                 context.ReportDiagnostic(
-                    name.Span, $"Test declaration '{name.Text}' lacks 'assert' statements");
+                    name.Span, $"Test declaration '{name.Text}' lacks 'assert' expressions");
     }
 }

src/language/core/Semantics/LanguageAnalyzer.cs

@@ -546,14 +546,6 @@ public override DeferStatementSemantics VisitDeferStatement(DeferStatementSyntax
             return new(node, attrs, expr);
         }
 
-        public override AssertStatementSemantics VisitAssertStatement(AssertStatementSyntax node)
-        {
-            var attrs = ConvertAttributeList(node, node.Attributes);
-            var expr = VisitExpression(node.Expression);
-
-            return new(node, attrs, expr);
-        }
-
         public override ExpressionStatementSemantics VisitExpressionStatement(ExpressionStatementSyntax node)
         {
             var attrs = ConvertAttributeList(node, node.Attributes);
@@ -1082,6 +1074,13 @@ public override MetaExpressionSemantics VisitMetaExpression(MetaExpressionSyntax
             return new(node, oper);
         }
 
+        public override AssertExpressionSemantics VisitAssertExpression(AssertExpressionSyntax node)
+        {
+            var cond = VisitExpression(node.Condition);
+
+            return new(node, cond);
+        }
+
         public override AssignmentExpressionSemantics VisitAssignmentExpression(AssignmentExpressionSyntax node)
         {
             var left = VisitExpression(node.LeftOperand);

src/language/core/Semantics/Tree/SemanticTree.xml

@@ -102,11 +102,6 @@
         <Node Name="Expression" Type="Expression" />
     </Type>
 
-    <Type Name="AssertStatement" Base="Statement">
-        <Nodes Name="Attribute" Type="Attribute" Override="true" />
-        <Node Name="Expression" Type="Expression" />
-    </Type>
-
     <Type Name="ExpressionStatement" Base="Statement">
         <Nodes Name="Attribute" Type="Attribute" Override="true" />
         <Node Name="Expression" Type="Expression" />
@@ -346,6 +341,10 @@
         <Node Name="Operand" Type="Expression" />
     </Type>
 
+    <Type Name="AssertExpression" Base="Expression">
+        <Node Name="Condition" Type="Expression" />
+    </Type>
+
     <Type Name="IdentifierExpression" Base="Expression">
         <Value Name="Symbol" Type="Symbol?" />
     </Type>

src/language/core/Syntax/LanguageParser.cs

@@ -1110,20 +1110,10 @@ private StatementSyntax ParseStatement(ImmutableArray<AttributeSyntax>.Builder a
         {
             SyntaxTokenKind.LetKeyword => ParseLetStatement(attributes),
             SyntaxTokenKind.DeferKeyword => ParseDeferStatement(attributes),
-            SyntaxTokenKind.AssertKeyword => ParseAssertStatement(attributes),
             _ => ParseExpressionStatement(attributes),
         };
     }
 
-    private AssertStatementSyntax ParseAssertStatement(ImmutableArray<AttributeSyntax>.Builder attributes)
-    {
-        var assert = Read();
-        var expr = ParseExpression();
-        var semi = Expect(SyntaxTokenKind.Semicolon);
-
-        return new(List(attributes), assert, expr, semi);
-    }
-
     private DeferStatementSyntax ParseDeferStatement(ImmutableArray<AttributeSyntax>.Builder attributes)
     {
         var defer = Read();
@@ -1294,6 +1284,7 @@ private ExpressionSyntax ParsePrimaryExpression()
             (var literal, _, _) when SyntaxFacts.IsLiteral(literal) => ParseLiteralExpression(),
             (SyntaxTokenKind.ThisKeyword, _, _) => ParseThisExpression(),
             (SyntaxTokenKind.MetaKeyword, _, _) => ParseMetaExpression(),
+            (SyntaxTokenKind.AssertKeyword, _, _) => ParseAssertExpression(),
             (SyntaxTokenKind.UpperIdentifier, _, _) => ParseModuleExpression(),
             (SyntaxTokenKind.FnKeyword, _, _) or
             (SyntaxTokenKind.ErrKeyword, SyntaxTokenKind.FnKeyword, _) => ParseLambdaExpression(),
@@ -1407,6 +1398,14 @@ private MetaExpressionSyntax ParseMetaExpression()
         return new(meta, oper);
     }
 
+    private AssertExpressionSyntax ParseAssertExpression()
+    {
+        var assert = Read();
+        var cond = ParseExpression();
+
+        return new(assert, cond);
+    }
+
     private LiteralExpressionSyntax ParseLiteralExpression()
     {
         var literal = Read();

src/language/core/Syntax/Tree/SyntaxTree.xml

@@ -395,13 +395,6 @@
         <Token Name="Semicolon" Override="true" />
     </Type>
 
-    <Type Name="AssertStatement" Base="Statement">
-        <Nodes Name="Attribute" Type="Attribute" Override="true" />
-        <Token Name="AssertKeyword" />
-        <Node Name="Expression" Type="Expression" />
-        <Token Name="Semicolon" Override="true" />
-    </Type>
-
     <Type Name="ExpressionStatement" Base="Statement">
         <Nodes Name="Attribute" Type="Attribute" Override="true" />
         <Node Name="Expression" Type="Expression" />
@@ -722,6 +715,11 @@
         <Node Name="Operand" Type="Expression" />
     </Type>
 
+    <Type Name="AssertExpression" Base="Expression">
+        <Token Name="AssertKeyword" />
+        <Node Name="Condition" Type="Expression" />
+    </Type>
+
     <Type Name="IdentifierExpression" Base="Expression">
         <Token Name="Name" />
     </Type>

src/tests/quality/tests_without_assert.diags.verified.txt

@@ -1,4 +1,4 @@
-Warning[test-without-assert]: Test declaration 'foo' lacks 'assert' statements
+Warning[test-without-assert]: Test declaration 'foo' lacks 'assert' expressions
 --> tests_without_assert.cel (2,10)-(2,13)
 1 | mod {
 2 |     test foo {