language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-01 22:31:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

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) {
m.abandon(p);
} else {
// test no_semi_after_block
// fn foo() {
// if true {}
// loop {}
// match () {}
// while true {}
// for _ in () {}
// {}
// {}
// }
if is_blocklike {
p.eat(SEMI);
} else {
@ -158,19 +168,18 @@ fn current_op(p: &Parser) -> (u8, Op) {
// Parses expression with binding power of at least bp.
fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
let mut lhs = match lhs(p, r) {
(Some(lhs), macro_blocklike) => {
Some((lhs, macro_blocklike)) => {
// test stmt_bin_expr_ambiguity
// fn foo() {
// let _ = {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;
}
lhs
}
(None, _) => return BlockLike::NotBlock,
None => return BlockLike::NotBlock,
};
loop {
@ -192,29 +201,12 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
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![
token_set![AMP, STAR, EXCL, DOTDOT, MINUS],
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 kind = match p.current() {
// test ref_expr
@ -247,30 +239,28 @@ fn lhs(p: &mut Parser, r: Restrictions) -> (Option<CompletedMarker>, Option<Bloc
if p.at_ts(EXPR_FIRST) {
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);
if macro_block_like == Some(BlockLike::Block) {
return (lhs_marker, macro_block_like);
}
if let Some(lhs_marker) = lhs_marker {
return (Some(postfix_expr(p, r, lhs_marker)), macro_block_like);
} else {
return (None, None);
}
let (lhs, blocklike) = atom::atom_expr(p, r)?;
return Some((
postfix_expr(p, lhs, !(r.prefer_stmt && blocklike.is_block())),
blocklike,
));
}
};
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
// E.g. `while true {break}();` is parsed as
// `while true {break}; ();`
let mut allow_calls = !r.prefer_stmt || !is_block(lhs.kind());
mut allow_calls: bool,
) -> CompletedMarker {
loop {
lhs = match p.current() {
// test stmt_postfix_expr_ambiguity
@ -418,22 +408,21 @@ fn arg_list(p: &mut Parser) {
// let _ = ::a::<b>;
// 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));
let m = p.start();
paths::expr_path(p);
let res = match p.current() {
match p.current() {
L_CURLY if !r.forbid_structs => {
named_field_list(p);
m.complete(p, STRUCT_LIT)
(m.complete(p, STRUCT_LIT), BlockLike::Block)
}
EXCL => {
let block_like = items::macro_call_after_excl(p); // TODO: Use return type (BlockLike)
return (m.complete(p, MACRO_CALL), Some(block_like));
let block_like = items::macro_call_after_excl(p);
return (m.complete(p, MACRO_CALL), block_like);
}
_ => m.complete(p, PATH_EXPR),
};
(res, None)
_ => (m.complete(p, PATH_EXPR), BlockLike::NotBlock),
}
}
// test struct_lit