fix: allow omitting ';' after last block statement if it's an assignment

compiler/noirc_frontend/src/ast/statement.rs

@@ -104,14 +104,21 @@ impl StatementKind {
             ParserError::with_reason(ParserErrorReason::MissingSeparatingSemi, location);
 
         match self {
-            StatementKind::Let(_)
-            | StatementKind::Assign(_)
+            StatementKind::Let(_) => {
+                // To match rust, a let statement always requires a semicolon, even at the end of a block
+                if semi.is_none() {
+                    let reason = ParserErrorReason::MissingSemicolonAfterLet;
+                    emit_error(ParserError::with_reason(reason, location));
+                }
+                self
+            }
+            StatementKind::Assign(_)
             | StatementKind::Semi(_)
             | StatementKind::Break
             | StatementKind::Continue
             | StatementKind::Error => {
-                // To match rust, statements always require a semicolon, even at the end of a block
-                if semi.is_none() {
+                // These statements can omit the semicolon if they are the last statement in a block
+                if !last_statement_in_block && semi.is_none() {
                     emit_error(missing_semicolon);
                 }
                 self

compiler/noirc_frontend/src/parser/errors.rs

@@ -60,6 +60,8 @@ pub enum ParserErrorReason {
     ExpectedPatternButFoundType(Token),
     #[error("Expected a ; separating these two statements")]
     MissingSeparatingSemi,
+    #[error("Expected a ; after `let` statement")]
+    MissingSemicolonAfterLet,
     #[error("constrain keyword is deprecated")]
     ConstrainDeprecated,
     #[error(

compiler/noirc_frontend/src/parser/parser/expression.rs

@@ -652,7 +652,7 @@
     ///     = bool
     ///     | int
     ///     | str
     ///     | rawstr
     ///     | fmtstr
     ///     | QuoteExpression
     ///     | ArrayExpression
@@ -1100,6 +1100,39 @@
         assert_eq!(block.statements.len(), 3);
     }
 
+    #[test]
+    fn parses_block_expression_with_a_single_assignment() {
+        let src = "{ x = 1 }";
+        let _ = parse_expression_no_errors(src);
+    }
+
+    #[test]
+    fn parses_block_expression_with_a_single_break() {
+        let src = "{ break }";
+        let _ = parse_expression_no_errors(src);
+    }
+
+    #[test]
+    fn parses_block_expression_with_a_single_continue() {
+        let src = "{ continue }";
+        let _ = parse_expression_no_errors(src);
+    }
+
+    #[test]
+    fn parses_block_expression_with_a_single_let() {
+        let src = "
+        { let x = 1 }
+                  ^
+        ";
+        let (src, span) = get_source_with_error_span(src);
+        let mut parser = Parser::for_str_with_dummy_file(&src);
+        parser.parse_expression();
+        let reason = get_single_error_reason(&parser.errors, span);
+        let ParserErrorReason::MissingSemicolonAfterLet = reason else {
+            panic!("Expected a different error");
+        };
+    }
+
     #[test]
     fn parses_unsafe_expression() {
         let src = "