Add semicolons for consistency

[rust.git] / crates / parser / src / grammar / expressions / atom.rs

diff --git a/crates/parser/src/grammar/expressions/atom.rs b/crates/parser/src/grammar/expressions/atom.rs
index 18b63feb7b61c6ba0c9d78936026bae8e72600f6..7075ae297f01541e0b45087c4334e3debe34909b 100644 (file)
--- a/crates/parser/src/grammar/expressions/atom.rs
+++ b/crates/parser/src/grammar/expressions/atom.rs
@@ -1,5 +1,3 @@
-//! FIXME: write short doc here
-
 use super::*;
 
 // test expr_literals
@@ -15,8 +13,16 @@
 //     let _ = b"e";
 //     let _ = br"f";
 // }
-pub(crate) const LITERAL_FIRST: TokenSet =
-    TokenSet::new(&[TRUE_KW, FALSE_KW, INT_NUMBER, FLOAT_NUMBER, BYTE, CHAR, STRING, BYTE_STRING]);
+pub(crate) const LITERAL_FIRST: TokenSet = TokenSet::new(&[
+    T![true],
+    T![false],
+    INT_NUMBER,
+    FLOAT_NUMBER,
+    BYTE,
+    CHAR,
+    STRING,
+    BYTE_STRING,
+]);
 
 pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
     if !p.at_ts(LITERAL_FIRST) {
@@ -42,16 +48,18 @@ pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
         T![match],
         T![unsafe],
         T![return],
+        T![yield],
         T![break],
         T![continue],
         T![async],
         T![try],
+        T![const],
         T![loop],
         T![for],
         LIFETIME_IDENT,
     ]));
 
-const EXPR_RECOVERY_SET: TokenSet = TokenSet::new(&[LET_KW, R_DOLLAR]);
+const EXPR_RECOVERY_SET: TokenSet = TokenSet::new(&[T![let], R_DOLLAR]);
 
 pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
     if let Some(m) = literal(p) {
@@ -85,8 +93,8 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
                 // test labeled_block
                 // fn f() { 'label: {}; }
                 T!['{'] => {
-                    block_expr(p);
-                    m.complete(p, EFFECT_EXPR)
+                    stmt_list(p);
+                    m.complete(p, BLOCK_EXPR)
                 }
                 _ => {
                     // test_err misplaced_label_err
@@ -103,8 +111,8 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
             let m = p.start();
             p.bump(T![async]);
             p.eat(T![move]);
-            block_expr(p);
-            m.complete(p, EFFECT_EXPR)
+            stmt_list(p);
+            m.complete(p, BLOCK_EXPR)
         }
         T![match] => match_expr(p),
         // test unsafe_block
@@ -112,8 +120,16 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
         T![unsafe] if la == T!['{'] => {
             let m = p.start();
             p.bump(T![unsafe]);
-            block_expr(p);
-            m.complete(p, EFFECT_EXPR)
+            stmt_list(p);
+            m.complete(p, BLOCK_EXPR)
+        }
+        // test const_block
+        // fn f() { const { } }
+        T![const] if la == T!['{'] => {
+            let m = p.start();
+            p.bump(T![const]);
+            stmt_list(p);
+            m.complete(p, BLOCK_EXPR)
         }
         T!['{'] => {
             // test for_range_from
@@ -122,9 +138,12 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
             //        break;
             //    }
             // }
-            block_expr_unchecked(p)
+            let m = p.start();
+            stmt_list(p);
+            m.complete(p, BLOCK_EXPR)
         }
         T![return] => return_expr(p),
+        T![yield] => yield_expr(p),
         T![continue] => continue_expr(p),
         T![break] => break_expr(p, r),
         _ => {
@@ -133,9 +152,7 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
         }
     };
     let blocklike = match done.kind() {
-        IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR | EFFECT_EXPR => {
-            BlockLike::Block
-        }
+        IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => BlockLike::Block,
         _ => BlockLike::NotBlock,
     };
     Some((done, blocklike))
@@ -156,11 +173,13 @@ fn tuple_expr(p: &mut Parser) -> CompletedMarker {
     let mut saw_expr = false;
     while !p.at(EOF) && !p.at(T![')']) {
         saw_expr = true;
-        if !p.at_ts(EXPR_FIRST) {
-            p.error("expected expression");
+
+        // test tuple_attrs
+        // const A: (i64, i64) = (1, #[cfg(test)] 2);
+        if !expr(p) {
             break;
         }
-        expr(p);
+
         if !p.at(T![')']) {
             saw_comma = true;
             p.expect(T![,]);
@@ -190,7 +209,7 @@ fn array_expr(p: &mut Parser) -> CompletedMarker {
 
         // test array_attrs
         // const A: &[i64] = &[1, #[cfg(test)] 2];
-        if !expr_with_attrs(p) {
+        if !expr(p) {
             break;
         }
 
@@ -233,12 +252,10 @@ fn closure_expr(p: &mut Parser) -> CompletedMarker {
         // test lambda_ret_block
         // fn main() { || -> i32 { 92 }(); }
         block_expr(p);
+    } else if p.at_ts(EXPR_FIRST) {
+        expr(p);
     } else {
-        if p.at_ts(EXPR_FIRST) {
-            expr(p);
-        } else {
-            p.error("expected expression");
-        }
+        p.error("expected expression");
     }
     m.complete(p, CLOSURE_EXPR)
 }
@@ -357,7 +374,7 @@ fn match_expr(p: &mut Parser) -> CompletedMarker {
     if p.at(T!['{']) {
         match_arm_list(p);
     } else {
-        p.error("expected `{`")
+        p.error("expected `{`");
     }
     m.complete(p, MATCH_EXPR)
 }
@@ -383,20 +400,7 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
             error_block(p, "expected match arm");
             continue;
         }
-
-        // test match_arms_commas
-        // fn foo() {
-        //     match () {
-        //         _ => (),
-        //         _ => {}
-        //         _ => ()
-        //     }
-        // }
-        if match_arm(p).is_block() {
-            p.eat(T![,]);
-        } else if !p.at(T!['}']) {
-            p.expect(T![,]);
-        }
+        match_arm(p);
     }
     p.expect(T!['}']);
     m.complete(p, MATCH_ARM_LIST);
@@ -412,7 +416,7 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
 //         | X => (),
 //     };
 // }
-fn match_arm(p: &mut Parser) -> BlockLike {
+fn match_arm(p: &mut Parser) {
     let m = p.start();
     // test match_arms_outer_attributes
     // fn foo() {
@@ -434,21 +438,40 @@ fn match_arm(p: &mut Parser) -> BlockLike {
         match_guard(p);
     }
     p.expect(T![=>]);
-    let blocklike = expr_stmt(p).1;
+    let blocklike = match expr_stmt(p, None) {
+        Some((_, blocklike)) => blocklike,
+        None => BlockLike::NotBlock,
+    };
+
+    // test match_arms_commas
+    // fn foo() {
+    //     match () {
+    //         _ => (),
+    //         _ => {}
+    //         _ => ()
+    //     }
+    // }
+    if !p.eat(T![,]) && !blocklike.is_block() && !p.at(T!['}']) {
+        p.error("expected `,`");
+    }
     m.complete(p, MATCH_ARM);
-    blocklike
 }
 
 // test match_guard
 // fn foo() {
 //     match () {
 //         _ if foo => (),
+//         _ if let foo = bar => (),
 //     }
 // }
 fn match_guard(p: &mut Parser) -> CompletedMarker {
     assert!(p.at(T![if]));
     let m = p.start();
     p.bump(T![if]);
+    if p.eat(T![let]) {
+        patterns::pattern_top(p);
+        p.expect(T![=]);
+    }
     expr(p);
     m.complete(p, MATCH_GUARD)
 }
@@ -463,16 +486,18 @@ pub(crate) fn block_expr(p: &mut Parser) {
         p.error("expected a block");
         return;
     }
-    block_expr_unchecked(p);
+    let m = p.start();
+    stmt_list(p);
+    m.complete(p, BLOCK_EXPR);
 }
 
-fn block_expr_unchecked(p: &mut Parser) -> CompletedMarker {
+fn stmt_list(p: &mut Parser) -> CompletedMarker {
     assert!(p.at(T!['{']));
     let m = p.start();
     p.bump(T!['{']);
     expr_block_contents(p);
     p.expect(T!['}']);
-    m.complete(p, BLOCK_EXPR)
+    m.complete(p, STMT_LIST)
 }
 
 // test return_expr
@@ -489,6 +514,20 @@ fn return_expr(p: &mut Parser) -> CompletedMarker {
     }
     m.complete(p, RETURN_EXPR)
 }
+// test yield_expr
+// fn foo() {
+//     yield;
+//     yield 1;
+// }
+fn yield_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T![yield]));
+    let m = p.start();
+    p.bump(T![yield]);
+    if p.at_ts(EXPR_FIRST) {
+        expr(p);
+    }
+    m.complete(p, YIELD_EXPR)
+}
 
 // test continue_expr
 // fn foo() {
@@ -560,8 +599,12 @@ fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
     }
 
     p.bump(T![try]);
-    block_expr(p);
-    m.complete(p, EFFECT_EXPR)
+    if p.at(T!['{']) {
+        stmt_list(p);
+    } else {
+        p.error("expected a block");
+    }
+    m.complete(p, BLOCK_EXPR)
 }
 
 // test box_expr
@@ -585,18 +628,18 @@ fn meta_var_expr(p: &mut Parser) -> CompletedMarker {
     assert!(p.at(L_DOLLAR));
     let m = p.start();
     p.bump(L_DOLLAR);
-    let (completed, _is_block) =
-        expr_bp(p, Restrictions { forbid_structs: false, prefer_stmt: false }, 1);
+    let expr = expr_bp(p, None, Restrictions { forbid_structs: false, prefer_stmt: false }, 1);
 
-    match (completed, p.current()) {
-        (Some(it), R_DOLLAR) => {
+    match (expr, p.current()) {
+        (Some((cm, _)), R_DOLLAR) => {
             p.bump(R_DOLLAR);
+            // FIXME: this leaves the dollar hanging in the air...
             m.abandon(p);
-            it
+            cm
         }
         _ => {
             while !p.at(R_DOLLAR) {
-                p.bump_any()
+                p.bump_any();
             }
             p.bump(R_DOLLAR);
             m.complete(p, ERROR)