language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-02 06:41:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Move is_block to lower in the call tree

Browse source
This commit is contained in:
DJMcNab 2018-12-19 20:55:24 +00:00
parent def0a95d35
commit db67741430
4 changed files with 104 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

77
crates/ra_syntax/src/grammar/expressions.rs
View file

@ -64,6 +64,16 @@ pub(crate) fn block(p: &mut Parser) {
if p.at(R_CURLY) { if p.at(R_CURLY) {
m.abandon(p); m.abandon(p);
} else { } else {
// test no_semi_after_block
// fn foo() {
// if true {}
// loop {}
// match () {}
// while true {}
// for _ in () {}
// {}
// {}
// }
if is_blocklike { if is_blocklike {
p.eat(SEMI); p.eat(SEMI);
} else { } else {
@ -158,19 +168,18 @@ fn current_op(p: &Parser) -> (u8, Op) {
// Parses expression with binding power of at least bp. // Parses expression with binding power of at least bp.
fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike { fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
let mut lhs = match lhs(p, r) { let mut lhs = match lhs(p, r) {
(Some(lhs), macro_blocklike) => { Some((lhs, macro_blocklike)) => {
// test stmt_bin_expr_ambiguity // test stmt_bin_expr_ambiguity
// fn foo() { // fn foo() {
// let _ = {1} & 2; // let _ = {1} & 2;
// {1} &2; // {1} &2;
// } // }
if r.prefer_stmt && (is_block(lhs.kind()) || macro_blocklike == Some(BlockLike::Block)) if r.prefer_stmt && macro_blocklike.is_block() {
{
return BlockLike::Block; return BlockLike::Block;
} }
lhs lhs
} }
(None, _) => return BlockLike::NotBlock, None => return BlockLike::NotBlock,
}; };
loop { loop {
@ -192,29 +201,12 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
BlockLike::NotBlock BlockLike::NotBlock
} }
// test no_semi_after_block
// fn foo() {
// if true {}
// loop {}
// match () {}
// while true {}
// for _ in () {}
// {}
// {}
// }
fn is_block(kind: SyntaxKind) -> bool {
match kind {
IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => true,
_ => false,
}
}
const LHS_FIRST: TokenSet = token_set_union![ const LHS_FIRST: TokenSet = token_set_union![
token_set![AMP, STAR, EXCL, DOTDOT, MINUS], token_set![AMP, STAR, EXCL, DOTDOT, MINUS],
atom::ATOM_EXPR_FIRST, atom::ATOM_EXPR_FIRST,
]; ];
fn lhs(p: &mut Parser, r: Restrictions) -> (Option<CompletedMarker>, Option<BlockLike>) { fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
let m; let m;
let kind = match p.current() { let kind = match p.current() {
// test ref_expr // test ref_expr
@ -247,30 +239,28 @@ fn lhs(p: &mut Parser, r: Restrictions) -> (Option<CompletedMarker>, Option<Bloc
if p.at_ts(EXPR_FIRST) { if p.at_ts(EXPR_FIRST) {
expr_bp(p, r, 2); expr_bp(p, r, 2);
} }
return (Some(m.complete(p, RANGE_EXPR)), None); return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
} }
_ => { _ => {
let (lhs_marker, macro_block_like) = atom::atom_expr(p, r); let (lhs, blocklike) = atom::atom_expr(p, r)?;
return Some((
if macro_block_like == Some(BlockLike::Block) { postfix_expr(p, lhs, !(r.prefer_stmt && blocklike.is_block())),
return (lhs_marker, macro_block_like); blocklike,
} ));
if let Some(lhs_marker) = lhs_marker {
return (Some(postfix_expr(p, r, lhs_marker)), macro_block_like);
} else {
return (None, None);
}
} }
}; };
expr_bp(p, r, 255); expr_bp(p, r, 255);
(Some(m.complete(p, kind)), None) Some((m.complete(p, kind), BlockLike::NotBlock))
} }
fn postfix_expr(p: &mut Parser, r: Restrictions, mut lhs: CompletedMarker) -> CompletedMarker { fn postfix_expr(
p: &mut Parser,
mut lhs: CompletedMarker,
// Calls are disallowed if the type is a block and we prefer statements because the call cannot be disambiguated from a tuple // Calls are disallowed if the type is a block and we prefer statements because the call cannot be disambiguated from a tuple
// E.g. `while true {break}();` is parsed as // E.g. `while true {break}();` is parsed as
// `while true {break}; ();` // `while true {break}; ();`
let mut allow_calls = !r.prefer_stmt || !is_block(lhs.kind()); mut allow_calls: bool,
) -> CompletedMarker {
loop { loop {
lhs = match p.current() { lhs = match p.current() {
// test stmt_postfix_expr_ambiguity // test stmt_postfix_expr_ambiguity
@ -418,22 +408,21 @@ fn arg_list(p: &mut Parser) {
// let _ = ::a::<b>; // let _ = ::a::<b>;
// let _ = format!(); // let _ = format!();
// } // }
fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, Option<BlockLike>) { fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
assert!(paths::is_path_start(p) || p.at(L_ANGLE)); assert!(paths::is_path_start(p) || p.at(L_ANGLE));
let m = p.start(); let m = p.start();
paths::expr_path(p); paths::expr_path(p);
let res = match p.current() { match p.current() {
L_CURLY if !r.forbid_structs => { L_CURLY if !r.forbid_structs => {
named_field_list(p); named_field_list(p);
m.complete(p, STRUCT_LIT) (m.complete(p, STRUCT_LIT), BlockLike::Block)
} }
EXCL => { EXCL => {
let block_like = items::macro_call_after_excl(p); // TODO: Use return type (BlockLike) let block_like = items::macro_call_after_excl(p);
return (m.complete(p, MACRO_CALL), Some(block_like)); return (m.complete(p, MACRO_CALL), block_like);
} }
_ => m.complete(p, PATH_EXPR), _ => (m.complete(p, PATH_EXPR), BlockLike::NotBlock),
}; }
(res, None)
} }
// test struct_lit // test struct_lit

20
crates/ra_syntax/src/grammar/expressions/atom.rs
View file

@ -61,16 +61,12 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet = token_set_union![
const EXPR_RECOVERY_SET: TokenSet = token_set![LET_KW]; const EXPR_RECOVERY_SET: TokenSet = token_set![LET_KW];
pub(super) fn atom_expr( pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
p: &mut Parser,
r: Restrictions,
) -> (Option<CompletedMarker>, Option<BlockLike>) {
if let Some(m) = literal(p) { if let Some(m) = literal(p) {
return (Some(m), None); return Some((m, BlockLike::NotBlock));
} }
if paths::is_path_start(p) || p.at(L_ANGLE) { if paths::is_path_start(p) || p.at(L_ANGLE) {
let path_expr = path_expr(p, r); return Some(path_expr(p, r));
return (Some(path_expr.0), path_expr.1);
} }
let la = p.nth(1); let la = p.nth(1);
let done = match p.current() { let done = match p.current() {
@ -98,7 +94,7 @@ pub(super) fn atom_expr(
// } // }
p.error("expected a loop"); p.error("expected a loop");
m.complete(p, ERROR); m.complete(p, ERROR);
return (None, None); return None;
} }
} }
} }
@ -115,10 +111,14 @@ pub(super) fn atom_expr(
BREAK_KW => break_expr(p), BREAK_KW => break_expr(p),
_ => { _ => {
p.err_recover("expected expression", EXPR_RECOVERY_SET); p.err_recover("expected expression", EXPR_RECOVERY_SET);
return (None, None); return None;
} }
}; };
(Some(done), None) let blocklike = match done.kind() {
IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => BlockLike::Block,
_ => BlockLike::NotBlock,
};
Some((done, blocklike))
} }
// test tuple_expr // test tuple_expr

2
crates/ra_syntax/tests/data/parser/inline/0094_range_pat.rs
View file

@ -1,5 +1,5 @@
fn main() { fn main() {
match 92 { match 92 {
0 ... 100 => (), 0 ... 100 => (),
101 ..= 200 => (), 101 ..= 200 => (),
200 .. 301=> (), 200 .. 301=> (),

120
crates/ra_syntax/tests/data/parser/inline/0094_range_pat.txt
View file

@ -1,5 +1,5 @@
SOURCE_FILE@[0; 113) SOURCE_FILE@[0; 112)
FN_DEF@[0; 112) FN_DEF@[0; 111)
FN_KW@[0; 2) FN_KW@[0; 2)
WHITESPACE@[2; 3) WHITESPACE@[2; 3)
NAME@[3; 7) NAME@[3; 7)
@ -8,69 +8,69 @@ SOURCE_FILE@[0; 113)
L_PAREN@[7; 8) L_PAREN@[7; 8)
R_PAREN@[8; 9) R_PAREN@[8; 9)
WHITESPACE@[9; 10) WHITESPACE@[9; 10)
BLOCK@[10; 112) BLOCK@[10; 111)
L_CURLY@[10; 11) L_CURLY@[10; 11)
WHITESPACE@[11; 16) WHITESPACE@[11; 16)
MATCH_EXPR@[16; 110) MATCH_EXPR@[16; 109)
MATCH_KW@[16; 21) MATCH_KW@[16; 21)
WHITESPACE@[21; 22) WHITESPACE@[21; 22)
LITERAL@[22; 24) LITERAL@[22; 24)
INT_NUMBER@[22; 24) "92" INT_NUMBER@[22; 24) "92"
WHITESPACE@[24; 25) WHITESPACE@[24; 25)
MATCH_ARM_LIST@[25; 110) MATCH_ARM_LIST@[25; 109)
L_CURLY@[25; 26) L_CURLY@[25; 26)
WHITESPACE@[26; 36) WHITESPACE@[26; 35)
MATCH_ARM@[36; 51) MATCH_ARM@[35; 50)
RANGE_PAT@[36; 45) RANGE_PAT@[35; 44)
LITERAL@[36; 37) LITERAL@[35; 36)
INT_NUMBER@[36; 37) "0" INT_NUMBER@[35; 36) "0"
WHITESPACE@[37; 38) WHITESPACE@[36; 37)
DOTDOTDOT@[38; 41) DOTDOTDOT@[37; 40)
WHITESPACE@[41; 42) WHITESPACE@[40; 41)
LITERAL@[42; 45) LITERAL@[41; 44)
INT_NUMBER@[42; 45) "100" INT_NUMBER@[41; 44) "100"
WHITESPACE@[45; 46) WHITESPACE@[44; 45)
FAT_ARROW@[46; 48) FAT_ARROW@[45; 47)
WHITESPACE@[48; 49) WHITESPACE@[47; 48)
TUPLE_EXPR@[49; 51) TUPLE_EXPR@[48; 50)
L_PAREN@[49; 50) L_PAREN@[48; 49)
R_PAREN@[50; 51) R_PAREN@[49; 50)
COMMA@[51; 52) COMMA@[50; 51)
WHITESPACE@[52; 61) WHITESPACE@[51; 60)
MATCH_ARM@[61; 78) MATCH_ARM@[60; 77)
RANGE_PAT@[61; 72) RANGE_PAT@[60; 71)
LITERAL@[61; 64) LITERAL@[60; 63)
INT_NUMBER@[61; 64) "101" INT_NUMBER@[60; 63) "101"
WHITESPACE@[64; 65) WHITESPACE@[63; 64)
DOTDOTEQ@[65; 68) DOTDOTEQ@[64; 67)
WHITESPACE@[68; 69) WHITESPACE@[67; 68)
LITERAL@[69; 72) LITERAL@[68; 71)
INT_NUMBER@[69; 72) "200" INT_NUMBER@[68; 71) "200"
WHITESPACE@[72; 73) WHITESPACE@[71; 72)
FAT_ARROW@[73; 75) FAT_ARROW@[72; 74)
WHITESPACE@[75; 76) WHITESPACE@[74; 75)
TUPLE_EXPR@[76; 78) TUPLE_EXPR@[75; 77)
L_PAREN@[76; 77) L_PAREN@[75; 76)
R_PAREN@[77; 78) R_PAREN@[76; 77)
COMMA@[78; 79) COMMA@[77; 78)
WHITESPACE@[79; 88) WHITESPACE@[78; 87)
MATCH_ARM@[88; 103) MATCH_ARM@[87; 102)
RANGE_PAT@[88; 98) RANGE_PAT@[87; 97)
LITERAL@[88; 91) LITERAL@[87; 90)
INT_NUMBER@[88; 91) "200" INT_NUMBER@[87; 90) "200"
WHITESPACE@[91; 92) WHITESPACE@[90; 91)
DOTDOT@[92; 94) DOTDOT@[91; 93)
WHITESPACE@[94; 95) WHITESPACE@[93; 94)
LITERAL@[95; 98) LITERAL@[94; 97)
INT_NUMBER@[95; 98) "301" INT_NUMBER@[94; 97) "301"
FAT_ARROW@[98; 100) FAT_ARROW@[97; 99)
WHITESPACE@[100; 101) WHITESPACE@[99; 100)
TUPLE_EXPR@[101; 103) TUPLE_EXPR@[100; 102)
L_PAREN@[101; 102) L_PAREN@[100; 101)
R_PAREN@[102; 103) R_PAREN@[101; 102)
COMMA@[103; 104) COMMA@[102; 103)
WHITESPACE@[104; 109) WHITESPACE@[103; 108)
R_CURLY@[109; 110) R_CURLY@[108; 109)
WHITESPACE@[110; 111) WHITESPACE@[109; 110)
R_CURLY@[111; 112) R_CURLY@[110; 111)
WHITESPACE@[112; 113) WHITESPACE@[111; 112)