language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-08-31 07:37:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Fix parsing of "postfix" range expressions.

Browse source 
Right now they are handled in `postfix_dot_expr`, but that doesn't allow it to
correctly handle precedence. Integrate it more tightly with the Pratt parser
instead.

Also includes a drive-by fix for parsing `match .. {}`.

Fixes #2242.
This commit is contained in:
Geoffry Song 2019-11-15 00:08:43 -08:00
parent 3ad11973ac
commit 989cebc99c
7 changed files with 142 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

54
crates/ra_parser/src/grammar/expressions.rs
View file

@ -290,6 +290,25 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
let m = lhs.precede(p);
p.bump(op);
if is_range {
// test postfix_range
// fn foo() {
// let x = 1..;
// match 1.. { _ => () };
// match a.b()..S { _ => () };
// }
let has_trailing_expression =
p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{']));
if !has_trailing_expression {
if op == T![..=] {
p.error("expected expression to end inclusive range");
}
// no RHS
lhs = m.complete(p, RANGE_EXPR);
break;
}
}
expr_bp(p, r, op_bp + 1);
lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR });
}
@ -330,7 +349,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
if p.at(op) {
m = p.start();
p.bump(op);
if p.at_ts(EXPR_FIRST) {
if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(T!['{'])) {
expr_bp(p, r, 2);
}
return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
@ -344,13 +363,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
// }
//
let (lhs, blocklike) = atom::atom_expr(p, r)?;
return Some(postfix_expr(
p,
lhs,
blocklike,
!(r.prefer_stmt && blocklike.is_block()),
r.forbid_structs,
));
return Some(postfix_expr(p, lhs, blocklike, !(r.prefer_stmt && blocklike.is_block())));
}
};
// parse the interior of the unary expression
@ -366,7 +379,6 @@ fn postfix_expr(
// `while true {break}; ();`
mut block_like: BlockLike,
mut allow_calls: bool,
forbid_structs: bool,
) -> (CompletedMarker, BlockLike) {
loop {
lhs = match p.current() {
@ -380,7 +392,7 @@ fn postfix_expr(
// }
T!['('] if allow_calls => call_expr(p, lhs),
T!['['] if allow_calls => index_expr(p, lhs),
T![.] => match postfix_dot_expr(p, lhs, forbid_structs) {
T![.] => match postfix_dot_expr(p, lhs) {
Ok(it) => it,
Err(it) => {
lhs = it;
@ -398,7 +410,6 @@ fn postfix_expr(
fn postfix_dot_expr(
p: &mut Parser,
lhs: CompletedMarker,
forbid_structs: bool,
) -> Result<CompletedMarker, CompletedMarker> {
assert!(p.at(T![.]));
if p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth_at(2, T![::])) {
@ -418,25 +429,8 @@ fn postfix_expr(
return Ok(m.complete(p, AWAIT_EXPR));
}
// test postfix_range
// fn foo() {
// let x = 1..;
// match 1.. { _ => () };
// match a.b()..S { _ => () };
// }
for &(op, la) in &[(T![..=], 3), (T![..], 2)] {
if p.at(op) {
let next_token = p.nth(la);
let has_trailing_expression =
!(forbid_structs && next_token == T!['{']) && EXPR_FIRST.contains(next_token);
return if has_trailing_expression {
Err(lhs)
} else {
let m = lhs.precede(p);
p.bump(op);
Ok(m.complete(p, RANGE_EXPR))
};
}
if p.at(T![..=]) || p.at(T![..]) {
return Err(lhs);
}
Ok(field_expr(p, lhs))