Replace SyntaxKind usage with T! macro where applicable

[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 ba6dd2fbcc4681944f039a321b5109cad9f0b054..d61950b96a049a9a37779e15b91f9a5ccfec48d1 100644 (file)
--- a/crates/parser/src/grammar/expressions/atom.rs
+++ b/crates/parser/src/grammar/expressions/atom.rs
@@ -15,18 +15,16 @@
 //     let _ = b"e";
 //     let _ = br"f";
 // }
-pub(crate) const LITERAL_FIRST: TokenSet = token_set![
-    TRUE_KW,
-    FALSE_KW,
+pub(crate) const LITERAL_FIRST: TokenSet = TokenSet::new(&[
+    T![true],
+    T![false],
     INT_NUMBER,
     FLOAT_NUMBER,
     BYTE,
     CHAR,
     STRING,
-    RAW_STRING,
     BYTE_STRING,
-    RAW_BYTE_STRING
-];
+]);
 
 pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
     if !p.at_ts(LITERAL_FIRST) {
@@ -39,7 +37,7 @@ pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
 
 // E.g. for after the break in `if break {}`, this should not match
 pub(super) const ATOM_EXPR_FIRST: TokenSet =
-    LITERAL_FIRST.union(paths::PATH_FIRST).union(token_set![
+    LITERAL_FIRST.union(paths::PATH_FIRST).union(TokenSet::new(&[
         T!['('],
         T!['{'],
         T!['['],
@@ -56,12 +54,13 @@ pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
         T![continue],
         T![async],
         T![try],
+        T![const],
         T![loop],
         T![for],
-        LIFETIME,
-    ]);
+        LIFETIME_IDENT,
+    ]));
 
-const EXPR_RECOVERY_SET: TokenSet = token_set![LET_KW, R_DOLLAR];
+const EXPR_RECOVERY_SET: TokenSet = TokenSet::new(&[LET_KW, R_DOLLAR]);
 
 pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
     if let Some(m) = literal(p) {
@@ -85,7 +84,7 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
         T![for] => for_expr(p, None),
         T![while] => while_expr(p, None),
         T![try] => try_block_expr(p, None),
-        LIFETIME if la == T![:] => {
+        LIFETIME_IDENT if la == T![:] => {
             let m = p.start();
             label(p);
             match p.current() {
@@ -125,6 +124,14 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
             block_expr(p);
             m.complete(p, EFFECT_EXPR)
         }
+        // test const_block
+        // fn f() { const { } }
+        T![const] if la == T!['{'] => {
+            let m = p.start();
+            p.bump(T![const]);
+            block_expr(p);
+            m.complete(p, EFFECT_EXPR)
+        }
         T!['{'] => {
             // test for_range_from
             // fn foo() {
@@ -166,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_with_attrs(p) {
             break;
         }
-        expr(p);
+
         if !p.at(T![')']) {
             saw_comma = true;
             p.expect(T![,]);
@@ -285,9 +294,9 @@ fn if_expr(p: &mut Parser) -> CompletedMarker {
 //     'c: for x in () {}
 // }
 fn label(p: &mut Parser) {
-    assert!(p.at(LIFETIME) && p.nth(1) == T![:]);
+    assert!(p.at(LIFETIME_IDENT) && p.nth(1) == T![:]);
     let m = p.start();
-    p.bump(LIFETIME);
+    lifetime(p);
     p.bump_any();
     m.complete(p, LABEL);
 }
@@ -511,7 +520,9 @@ fn continue_expr(p: &mut Parser) -> CompletedMarker {
     assert!(p.at(T![continue]));
     let m = p.start();
     p.bump(T![continue]);
-    p.eat(LIFETIME);
+    if p.at(LIFETIME_IDENT) {
+        lifetime(p);
+    }
     m.complete(p, CONTINUE_EXPR)
 }
 
@@ -528,7 +539,9 @@ fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
     assert!(p.at(T![break]));
     let m = p.start();
     p.bump(T![break]);
-    p.eat(LIFETIME);
+    if p.at(LIFETIME_IDENT) {
+        lifetime(p);
+    }
     // test break_ambiguity
     // fn foo(){
     //     if break {}