From 993abedd77cf23ce2281b6c8e60cab49ab4fa97e Mon Sep 17 00:00:00 2001 From: Sergey Parilin Date: Wed, 15 May 2019 15:35:47 +0300 Subject: apply T! macro where it is possible --- crates/ra_parser/src/grammar/expressions/atom.rs | 144 +++++++++++------------ 1 file changed, 72 insertions(+), 72 deletions(-) (limited to 'crates/ra_parser/src/grammar/expressions') diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs index 8dc7e44a9..8b1a1de49 100644 --- a/crates/ra_parser/src/grammar/expressions/atom.rs +++ b/crates/ra_parser/src/grammar/expressions/atom.rs @@ -60,29 +60,29 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar if let Some(m) = literal(p) { return Some((m, BlockLike::NotBlock)); } - if paths::is_path_start(p) || p.at(L_ANGLE) { + if paths::is_path_start(p) || p.at(T![<]) { return Some(path_expr(p, r)); } let la = p.nth(1); let done = match p.current() { - L_PAREN => tuple_expr(p), - L_BRACK => array_expr(p), - PIPE => lambda_expr(p), - MOVE_KW if la == PIPE => lambda_expr(p), - ASYNC_KW if la == PIPE || (la == MOVE_KW && p.nth(2) == PIPE) => lambda_expr(p), - IF_KW => if_expr(p), + T!['('] => tuple_expr(p), + T!['['] => array_expr(p), + T![|] => lambda_expr(p), + T![move] if la == T![|] => lambda_expr(p), + T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => lambda_expr(p), + T![if] => if_expr(p), - LOOP_KW => loop_expr(p, None), - FOR_KW => for_expr(p, None), - WHILE_KW => while_expr(p, None), - LIFETIME if la == COLON => { + T![loop] => loop_expr(p, None), + T![for] => for_expr(p, None), + T![while] => while_expr(p, None), + LIFETIME if la == T![:] => { let m = p.start(); label(p); match p.current() { - LOOP_KW => loop_expr(p, Some(m)), - FOR_KW => for_expr(p, Some(m)), - WHILE_KW => while_expr(p, Some(m)), - L_CURLY => block_expr(p, Some(m)), + T![loop] => loop_expr(p, Some(m)), + T![for] => for_expr(p, Some(m)), + T![while] => while_expr(p, Some(m)), + T!['{'] => block_expr(p, Some(m)), _ => { // test_err misplaced_label_err // fn main() { @@ -94,22 +94,22 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar } } } - ASYNC_KW if la == L_CURLY || (la == MOVE_KW && p.nth(2) == L_CURLY) => { + T![async] if la == T!['{'] || (la == T![move] && p.nth(2) == T!['{']) => { let m = p.start(); p.bump(); - p.eat(MOVE_KW); + p.eat(T![move]); block_expr(p, Some(m)) } - MATCH_KW => match_expr(p), - UNSAFE_KW if la == L_CURLY => { + T![match] => match_expr(p), + T![unsafe] if la == T!['{'] => { let m = p.start(); p.bump(); block_expr(p, Some(m)) } - L_CURLY => block_expr(p, None), - RETURN_KW => return_expr(p), - CONTINUE_KW => continue_expr(p), - BREAK_KW => break_expr(p, r), + T!['{'] => block_expr(p, None), + T![return] => return_expr(p), + T![continue] => continue_expr(p), + T![break] => break_expr(p, r), _ => { p.err_recover("expected expression", EXPR_RECOVERY_SET); return None; @@ -129,25 +129,25 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar // (1,); // } fn tuple_expr(p: &mut Parser) -> CompletedMarker { - assert!(p.at(L_PAREN)); + assert!(p.at(T!['('])); let m = p.start(); - p.expect(L_PAREN); + p.expect(T!['(']); let mut saw_comma = false; let mut saw_expr = false; - while !p.at(EOF) && !p.at(R_PAREN) { + while !p.at(EOF) && !p.at(T![')']) { saw_expr = true; if !p.at_ts(EXPR_FIRST) { p.error("expected expression"); break; } expr(p); - if !p.at(R_PAREN) { + if !p.at(T![')']) { saw_comma = true; - p.expect(COMMA); + p.expect(T![,]); } } - p.expect(R_PAREN); + p.expect(T![')']); m.complete(p, if saw_expr && !saw_comma { PAREN_EXPR } else { TUPLE_EXPR }) } @@ -159,21 +159,21 @@ fn tuple_expr(p: &mut Parser) -> CompletedMarker { // [1; 2]; // } fn array_expr(p: &mut Parser) -> CompletedMarker { - assert!(p.at(L_BRACK)); + assert!(p.at(T!['['])); let m = p.start(); p.bump(); - if p.eat(R_BRACK) { + if p.eat(T![']']) { return m.complete(p, ARRAY_EXPR); } expr(p); - if p.eat(SEMI) { + if p.eat(T![;]) { expr(p); - p.expect(R_BRACK); + p.expect(T![']']); return m.complete(p, ARRAY_EXPR); } - while !p.at(EOF) && !p.at(R_BRACK) { - p.expect(COMMA); - if p.at(R_BRACK) { + while !p.at(EOF) && !p.at(T![']']) { + p.expect(T![,]); + if p.at(T![']']) { break; } if !p.at_ts(EXPR_FIRST) { @@ -182,7 +182,7 @@ fn array_expr(p: &mut Parser) -> CompletedMarker { } expr(p); } - p.expect(R_BRACK); + p.expect(T![']']); m.complete(p, ARRAY_EXPR) } @@ -198,17 +198,17 @@ fn array_expr(p: &mut Parser) -> CompletedMarker { // } fn lambda_expr(p: &mut Parser) -> CompletedMarker { assert!( - p.at(PIPE) - || (p.at(MOVE_KW) && p.nth(1) == PIPE) - || (p.at(ASYNC_KW) && p.nth(1) == PIPE) - || (p.at(ASYNC_KW) && p.nth(1) == MOVE_KW && p.nth(2) == PIPE) + p.at(T![|]) + || (p.at(T![move]) && p.nth(1) == T![|]) + || (p.at(T![async]) && p.nth(1) == T![|]) + || (p.at(T![async]) && p.nth(1) == T![move] && p.nth(2) == T![|]) ); let m = p.start(); - p.eat(ASYNC_KW); - p.eat(MOVE_KW); + p.eat(T![async]); + p.eat(T![move]); params::param_list_opt_types(p); if opt_fn_ret_type(p) { - if !p.at(L_CURLY) { + if !p.at(T!['{']) { p.error("expected `{`"); } } @@ -224,14 +224,14 @@ fn lambda_expr(p: &mut Parser) -> CompletedMarker { // if S {}; // } fn if_expr(p: &mut Parser) -> CompletedMarker { - assert!(p.at(IF_KW)); + assert!(p.at(T![if])); let m = p.start(); p.bump(); cond(p); block(p); - if p.at(ELSE_KW) { + if p.at(T![else]) { p.bump(); - if p.at(IF_KW) { + if p.at(T![if]) { if_expr(p); } else { block(p); @@ -247,7 +247,7 @@ fn if_expr(p: &mut Parser) -> CompletedMarker { // 'c: for x in () {} // } fn label(p: &mut Parser) { - assert!(p.at(LIFETIME) && p.nth(1) == COLON); + assert!(p.at(LIFETIME) && p.nth(1) == T![:]); let m = p.start(); p.bump(); p.bump(); @@ -259,7 +259,7 @@ fn label(p: &mut Parser) { // loop {}; // } fn loop_expr(p: &mut Parser, m: Option) -> CompletedMarker { - assert!(p.at(LOOP_KW)); + assert!(p.at(T![loop])); let m = m.unwrap_or_else(|| p.start()); p.bump(); block(p); @@ -272,7 +272,7 @@ fn loop_expr(p: &mut Parser, m: Option) -> CompletedMarker { // while let Some(x) = it.next() {}; // } fn while_expr(p: &mut Parser, m: Option) -> CompletedMarker { - assert!(p.at(WHILE_KW)); + assert!(p.at(T![while])); let m = m.unwrap_or_else(|| p.start()); p.bump(); cond(p); @@ -285,11 +285,11 @@ fn while_expr(p: &mut Parser, m: Option) -> CompletedMarker { // for x in [] {}; // } fn for_expr(p: &mut Parser, m: Option) -> CompletedMarker { - assert!(p.at(FOR_KW)); + assert!(p.at(T![for])); let m = m.unwrap_or_else(|| p.start()); p.bump(); patterns::pattern(p); - p.expect(IN_KW); + p.expect(T![in]); expr_no_struct(p); block(p); m.complete(p, FOR_EXPR) @@ -305,9 +305,9 @@ fn for_expr(p: &mut Parser, m: Option) -> CompletedMarker { // } fn cond(p: &mut Parser) { let m = p.start(); - if p.eat(LET_KW) { + if p.eat(T![let]) { patterns::pattern_list(p); - p.expect(EQ); + p.expect(T![=]); } expr_no_struct(p); m.complete(p, CONDITION); @@ -319,11 +319,11 @@ fn cond(p: &mut Parser) { // match S {}; // } fn match_expr(p: &mut Parser) -> CompletedMarker { - assert!(p.at(MATCH_KW)); + assert!(p.at(T![match])); let m = p.start(); p.bump(); expr_no_struct(p); - if p.at(L_CURLY) { + if p.at(T!['{']) { match_arm_list(p); } else { p.error("expected `{`") @@ -332,9 +332,9 @@ fn match_expr(p: &mut Parser) -> CompletedMarker { } pub(crate) fn match_arm_list(p: &mut Parser) { - assert!(p.at(L_CURLY)); + assert!(p.at(T!['{'])); let m = p.start(); - p.eat(L_CURLY); + p.eat(T!['{']); // test match_arms_inner_attribute // fn foo() { @@ -347,8 +347,8 @@ pub(crate) fn match_arm_list(p: &mut Parser) { // } attributes::inner_attributes(p); - while !p.at(EOF) && !p.at(R_CURLY) { - if p.at(L_CURLY) { + while !p.at(EOF) && !p.at(T!['}']) { + if p.at(T!['{']) { error_block(p, "expected match arm"); continue; } @@ -362,12 +362,12 @@ pub(crate) fn match_arm_list(p: &mut Parser) { // } // } if match_arm(p).is_block() { - p.eat(COMMA); - } else if !p.at(R_CURLY) { - p.expect(COMMA); + p.eat(T![,]); + } else if !p.at(T!['}']) { + p.expect(T![,]); } } - p.expect(R_CURLY); + p.expect(T!['}']); m.complete(p, MATCH_ARM_LIST); } @@ -399,10 +399,10 @@ fn match_arm(p: &mut Parser) -> BlockLike { attributes::outer_attributes(p); patterns::pattern_list_r(p, TokenSet::empty()); - if p.at(IF_KW) { + if p.at(T![if]) { match_guard(p); } - p.expect(FAT_ARROW); + p.expect(T![=>]); let blocklike = expr_stmt(p).1; m.complete(p, MATCH_ARM); blocklike @@ -415,7 +415,7 @@ fn match_arm(p: &mut Parser) -> BlockLike { // } // } fn match_guard(p: &mut Parser) -> CompletedMarker { - assert!(p.at(IF_KW)); + assert!(p.at(T![if])); let m = p.start(); p.bump(); expr(p); @@ -429,7 +429,7 @@ fn match_guard(p: &mut Parser) -> CompletedMarker { // 'label: {}; // } fn block_expr(p: &mut Parser, m: Option) -> CompletedMarker { - assert!(p.at(L_CURLY)); + assert!(p.at(T!['{'])); let m = m.unwrap_or_else(|| p.start()); block(p); m.complete(p, BLOCK_EXPR) @@ -441,7 +441,7 @@ fn block_expr(p: &mut Parser, m: Option) -> CompletedMarker { // return 92; // } fn return_expr(p: &mut Parser) -> CompletedMarker { - assert!(p.at(RETURN_KW)); + assert!(p.at(T![return])); let m = p.start(); p.bump(); if p.at_ts(EXPR_FIRST) { @@ -458,7 +458,7 @@ fn return_expr(p: &mut Parser) -> CompletedMarker { // } // } fn continue_expr(p: &mut Parser) -> CompletedMarker { - assert!(p.at(CONTINUE_KW)); + assert!(p.at(T![continue])); let m = p.start(); p.bump(); p.eat(LIFETIME); @@ -475,7 +475,7 @@ fn continue_expr(p: &mut Parser) -> CompletedMarker { // } // } fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker { - assert!(p.at(BREAK_KW)); + assert!(p.at(T![break])); let m = p.start(); p.bump(); p.eat(LIFETIME); @@ -486,7 +486,7 @@ fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker { // for i in break {} // match break {} // } - if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(L_CURLY)) { + if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{'])) { expr(p); } m.complete(p, BREAK_EXPR) -- cgit v1.2.3