add is_blocklike func on BlockLike

crates/parser/src/grammar.rs

@@ -198,6 +198,10 @@ impl BlockLike {
     fn is_block(self) -> bool {
         self == BlockLike::Block
     }
+
+    fn is_blocklike(kind: SyntaxKind) -> bool {
+        matches!(kind, BLOCK_EXPR | IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR)
+    }
 }
 
 const VISIBILITY_FIRST: TokenSet = TokenSet::new(&[T![pub], T![crate]]);

crates/parser/src/grammar/expressions.rs

@@ -121,27 +121,22 @@ fn let_stmt(p: &mut Parser<'_>, m: Marker, with_semi: Semicolon) {
             types::ascription(p);
         }
 
-        let mut is_block_like_expr_after_eq = false;
+        let mut expr_after_eq: Option<CompletedMarker> = None;
         if p.eat(T![=]) {
             // test let_stmt_init
             // fn f() { let x = 92; }
-            let expr = expressions::expr(p);
-
-            if let Some(expr) = expr {
-                is_block_like_expr_after_eq = match expr.kind() {
-                    IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => true,
-                    _ => false,
-                };
-            }
+            expr_after_eq = expressions::expr(p);
         }
 
         if p.at(T![else]) {
             // test_err let_else_right_curly_brace
             // fn func() { let Some(_) = {Some(1)} else { panic!("h") };}
-            if is_block_like_expr_after_eq {
-                p.error(
-                    "right curly brace `}` before `else` in a `let...else` statement not allowed",
-                )
+            if let Some(expr) = expr_after_eq {
+                if BlockLike::is_blocklike(expr.kind()) {
+                    p.error(
+                        "right curly brace `}` before `else` in a `let...else` statement not allowed",
+                    )
+                }
             }
 
             // test let_else

crates/parser/src/grammar/expressions/atom.rs

@@ -163,10 +163,8 @@ pub(super) fn atom_expr(
             return None;
         }
     };
-    let blocklike = match done.kind() {
-        IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => BlockLike::Block,
-        _ => BlockLike::NotBlock,
-    };
+    let blocklike =
+        if BlockLike::is_blocklike(done.kind()) { BlockLike::Block } else { BlockLike::NotBlock };
     Some((done, blocklike))
 }