Skip to content

Commit 574c1f0

Browse files
sbilligsbillig
authored
Merge pull request #934 from sbillig/parser-tweaks
Modest parser improvements
2 parents ce8382f + 37afade commit 574c1f0

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

94 files changed

+2133
-812
lines changed

Diff for: ‎crates/analyzer/src/traversal/types.rs

-1
Original file line numberDiff line numberDiff line change
@@ -575,7 +575,6 @@ pub fn type_desc(
575575
if let Some(val) = self_type {
576576
Ok(Type::SelfType(val).id(context.db()))
577577
} else {
578-
dbg!("Reporting error");
579578
Err(TypeError::new(context.error(
580579
"`Self` can not be used here",
581580
desc.span,

Diff for: ‎crates/parser2/src/parser/attr.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ use crate::SyntaxKind;
44

55
pub(super) fn parse_attr_list<S: TokenStream>(parser: &mut Parser<S>) -> Option<Checkpoint> {
66
if let Some(SyntaxKind::DocComment) | Some(SyntaxKind::Pound) = parser.current_kind() {
7-
Some(parser.parse(super::attr::AttrListScope::default(), None).1)
7+
Some(parser.parse(AttrListScope::default(), None).1)
88
} else {
99
None
1010
}

Diff for: ‎crates/parser2/src/parser/expr.rs

+70-73
Original file line numberDiff line numberDiff line change
@@ -56,9 +56,6 @@ fn parse_expr_with_min_bp<S: TokenStream>(
5656

5757
// `expr<generic_param_args>()`.
5858
SyntaxKind::Lt => {
59-
//let is_call_expr =
60-
// parser.dry_run(|parser| parser.parse(CallExprScope::default(),
61-
// None).0);
6259
if is_call_expr(parser) {
6360
parser.parse(CallExprScope::default(), Some(checkpoint));
6461
continue;
@@ -83,16 +80,17 @@ fn parse_expr_with_min_bp<S: TokenStream>(
8380
break;
8481
}
8582

86-
if !match kind {
87-
// Method call is already handled as the postfix operator.
88-
SyntaxKind::Dot => parser.parse(FieldExprScope::default(), Some(checkpoint)).0,
89-
_ => {
90-
// 1. Try to parse the expression as an augmented assignment expression.
91-
// 2. If 1. fails, try to parse the expression as an assignment expression.
92-
// 3. If 2. fails, try to parse the expression as a binary expression.
93-
parser.parse(BinExprScope::default(), Some(checkpoint)).0
94-
}
95-
} {
83+
let (ok, _) = if kind == SyntaxKind::Dot {
84+
parser.parse(FieldExprScope::default(), Some(checkpoint))
85+
} else if is_asn(parser) {
86+
parser.parse(AssignExprScope::default(), Some(checkpoint))
87+
} else if is_aug(parser) {
88+
parser.parse(AugAssignExprScope::default(), Some(checkpoint))
89+
} else {
90+
parser.parse(BinExprScope::default(), Some(checkpoint))
91+
};
92+
93+
if !ok {
9694
return false;
9795
}
9896

@@ -202,21 +200,28 @@ impl super::Parse for BinExprScope {
202200
fn parse<S: TokenStream>(&mut self, parser: &mut Parser<S>) {
203201
parser.set_newline_as_trivia(false);
204202
let (_, rbp) = infix_binding_power(parser).unwrap();
205-
if is_aug(parser) {
206-
self.set_kind(SyntaxKind::AugAssignExpr);
207-
bump_aug_assign_op(parser);
208-
parser.bump_expected(SyntaxKind::Eq);
209-
parse_expr_with_min_bp(parser, rbp, true);
210-
} else if is_asn(parser) {
211-
self.set_kind(SyntaxKind::AssignExpr);
212-
parser.set_newline_as_trivia(false);
213-
let (_, rbp) = infix_binding_power(parser).unwrap();
214-
parser.bump_expected(SyntaxKind::Eq);
215-
parse_expr_with_min_bp(parser, rbp, true);
216-
} else {
217-
bump_bin_op(parser);
218-
parse_expr_with_min_bp(parser, rbp, false);
219-
}
203+
bump_bin_op(parser);
204+
parse_expr_with_min_bp(parser, rbp, false);
205+
}
206+
}
207+
208+
define_scope! { AugAssignExprScope, AugAssignExpr, Inheritance }
209+
impl super::Parse for AugAssignExprScope {
210+
fn parse<S: TokenStream>(&mut self, parser: &mut Parser<S>) {
211+
parser.set_newline_as_trivia(false);
212+
let (_, rbp) = infix_binding_power(parser).unwrap();
213+
bump_aug_assign_op(parser);
214+
parse_expr_with_min_bp(parser, rbp, false);
215+
}
216+
}
217+
218+
define_scope! { AssignExprScope, AssignExpr, Inheritance }
219+
impl super::Parse for AssignExprScope {
220+
fn parse<S: TokenStream>(&mut self, parser: &mut Parser<S>) {
221+
parser.set_newline_as_trivia(false);
222+
let (_, rbp) = infix_binding_power(parser).unwrap();
223+
parser.bump_expected(SyntaxKind::Eq);
224+
parse_expr_with_min_bp(parser, rbp, true);
220225
}
221226
}
222227

@@ -305,72 +310,69 @@ impl super::Parse for FieldExprScope {
305310
define_scope! { pub(super) LShiftScope, LShift, Inheritance }
306311
impl super::Parse for LShiftScope {
307312
fn parse<S: TokenStream>(&mut self, parser: &mut Parser<S>) {
308-
parser.bump_or_recover(SyntaxKind::Lt, "expected `<<`", None);
309-
parser.bump_or_recover(SyntaxKind::Lt, "expected `<<`", None);
313+
parser.bump_expected(SyntaxKind::Lt);
314+
parser.bump_expected(SyntaxKind::Lt);
310315
}
311316
}
312317

313318
define_scope! { pub(super) RShiftScope, RShift, Inheritance }
314319
impl super::Parse for RShiftScope {
315320
fn parse<S: TokenStream>(&mut self, parser: &mut Parser<S>) {
316-
parser.bump_or_recover(SyntaxKind::Gt, "expected `>>`", None);
317-
parser.bump_or_recover(SyntaxKind::Gt, "expected `>>`", None);
321+
parser.bump_expected(SyntaxKind::Gt);
322+
parser.bump_expected(SyntaxKind::Gt);
318323
}
319324
}
320325

321326
define_scope! { pub(super) LtEqScope, LtEq, Inheritance }
322327
impl super::Parse for LtEqScope {
323328
fn parse<S: TokenStream>(&mut self, parser: &mut Parser<S>) {
324-
parser.bump_or_recover(SyntaxKind::Lt, "expected `<=`", None);
325-
parser.bump_or_recover(SyntaxKind::Eq, "expected `<=`", None);
329+
parser.bump_expected(SyntaxKind::Lt);
330+
parser.bump_expected(SyntaxKind::Eq);
326331
}
327332
}
328333

329334
define_scope! { pub(super) GtEqScope, GtEq, Inheritance }
330335
impl super::Parse for GtEqScope {
331336
fn parse<S: TokenStream>(&mut self, parser: &mut Parser<S>) {
332-
parser.bump_or_recover(SyntaxKind::Gt, "expected `>=`", None);
333-
parser.bump_or_recover(SyntaxKind::Eq, "expected `>=`", None);
337+
parser.bump_expected(SyntaxKind::Gt);
338+
parser.bump_expected(SyntaxKind::Eq);
334339
}
335340
}
336341

337342
pub(crate) fn is_lshift<S: TokenStream>(parser: &mut Parser<S>) -> bool {
338-
parser.dry_run(|parser| parser.parse(LShiftScope::default(), None).0)
343+
parser.peek_two() == (Some(SyntaxKind::Lt), Some(SyntaxKind::Lt))
339344
}
340345

341346
pub(crate) fn is_rshift<S: TokenStream>(parser: &mut Parser<S>) -> bool {
342-
parser.dry_run(|parser| parser.parse(RShiftScope::default(), None).0)
347+
parser.peek_two() == (Some(SyntaxKind::Gt), Some(SyntaxKind::Gt))
343348
}
344349

345350
fn is_lt_eq<S: TokenStream>(parser: &mut Parser<S>) -> bool {
346-
parser.dry_run(|parser| parser.parse(LtEqScope::default(), None).0)
351+
parser.peek_two() == (Some(SyntaxKind::Lt), Some(SyntaxKind::Eq))
347352
}
348353

349354
fn is_gt_eq<S: TokenStream>(parser: &mut Parser<S>) -> bool {
350-
parser.dry_run(|parser| parser.parse(GtEqScope::default(), None).0)
355+
parser.peek_two() == (Some(SyntaxKind::Gt), Some(SyntaxKind::Eq))
351356
}
352357

353358
fn is_aug<S: TokenStream>(parser: &mut Parser<S>) -> bool {
354-
parser.dry_run(|parser| {
355-
if !bump_aug_assign_op(parser) {
356-
return false;
357-
}
358-
359-
parser.set_newline_as_trivia(false);
360-
parser.current_kind() == Some(SyntaxKind::Eq)
361-
})
359+
use SyntaxKind::*;
360+
matches!(
361+
parser.peek_three(),
362+
(
363+
Some(Pipe | Hat | Amp | Plus | Minus | Star | Slash | Percent | Star2),
364+
Some(Eq),
365+
_
366+
) | (Some(Lt), Some(Lt), Some(Eq))
367+
| (Some(Gt), Some(Gt), Some(Eq))
368+
)
362369
}
363370

364371
fn is_asn<S: TokenStream>(parser: &mut Parser<S>) -> bool {
365-
parser.dry_run(|parser| {
366-
parser.set_newline_as_trivia(false);
367-
if parser.current_kind() == Some(SyntaxKind::Eq) {
368-
parser.bump();
369-
true
370-
} else {
371-
false
372-
}
373-
})
372+
let nt = parser.set_newline_as_trivia(false);
373+
let is_asn = parser.current_kind() == Some(SyntaxKind::Eq);
374+
parser.set_newline_as_trivia(nt);
375+
is_asn
374376
}
375377

376378
fn bump_bin_op<S: TokenStream>(parser: &mut Parser<S>) {
@@ -401,26 +403,21 @@ fn bump_bin_op<S: TokenStream>(parser: &mut Parser<S>) {
401403

402404
fn bump_aug_assign_op<S: TokenStream>(parser: &mut Parser<S>) -> bool {
403405
use SyntaxKind::*;
404-
match parser.current_kind() {
405-
Some(Pipe | Hat | Amp | Plus | Minus | Star | Slash | Percent | Star2) => {
406+
match parser.peek_three() {
407+
(Some(Pipe | Hat | Amp | Plus | Minus | Star | Slash | Percent | Star2), Some(Eq), _) => {
408+
parser.bump();
406409
parser.bump();
407410
true
408411
}
409-
Some(Lt) => {
410-
if is_lshift(parser) {
411-
parser.parse(LShiftScope::default(), None);
412-
true
413-
} else {
414-
false
415-
}
412+
(Some(Lt), Some(Lt), Some(Eq)) => {
413+
parser.parse(LShiftScope::default(), None);
414+
parser.bump_expected(SyntaxKind::Eq);
415+
true
416416
}
417-
Some(Gt) => {
418-
if is_rshift(parser) {
419-
parser.parse(RShiftScope::default(), None);
420-
true
421-
} else {
422-
false
423-
}
417+
(Some(Gt), Some(Gt), Some(Eq)) => {
418+
parser.parse(RShiftScope::default(), None);
419+
parser.bump_expected(SyntaxKind::Eq);
420+
true
424421
}
425422
_ => false,
426423
}

Diff for: ‎crates/parser2/src/parser/expr_atom.rs

+11-11
Original file line numberDiff line numberDiff line change
@@ -105,21 +105,21 @@ impl super::Parse for IfExprScope {
105105
parser.parse(BlockExprScope::default(), None);
106106

107107
if parser.current_kind() == Some(SyntaxKind::ElseKw) {
108-
parser.with_next_expected_tokens(
108+
parser.bump_expected(SyntaxKind::ElseKw);
109+
110+
parser.with_recovery_tokens(
109111
|parser| {
110-
parser.bump_expected(SyntaxKind::ElseKw);
112+
if matches!(
113+
parser.current_kind(),
114+
Some(SyntaxKind::LBrace | SyntaxKind::IfKw)
115+
) {
116+
parse_expr(parser);
117+
} else {
118+
parser.error_and_recover("expected `{` or `if` after `else`", None);
119+
}
111120
},
112121
&[SyntaxKind::LBrace, SyntaxKind::IfKw],
113122
);
114-
115-
if !matches!(
116-
parser.current_kind(),
117-
Some(SyntaxKind::LBrace | SyntaxKind::IfKw)
118-
) {
119-
parser.error_and_recover("expected `{` or `if` after `else`", None);
120-
return;
121-
}
122-
parse_expr(parser);
123123
}
124124
}
125125
}

Diff for: ‎crates/parser2/src/parser/func.rs

+14-3
Original file line numberDiff line numberDiff line change
@@ -52,12 +52,23 @@ fn parse_normal_fn_def_impl<S: TokenStream>(parser: &mut Parser<S>, allow_self:
5252
None,
5353
)
5454
},
55-
&[SyntaxKind::Lt, SyntaxKind::LParen, SyntaxKind::LBrace],
55+
&[
56+
SyntaxKind::Lt,
57+
SyntaxKind::LParen,
58+
SyntaxKind::Arrow,
59+
SyntaxKind::WhereKw,
60+
SyntaxKind::LBrace,
61+
],
5662
);
5763

5864
parser.with_next_expected_tokens(
5965
|parser| parse_generic_params_opt(parser, false),
60-
&[SyntaxKind::LParen, SyntaxKind::LBrace],
66+
&[
67+
SyntaxKind::LParen,
68+
SyntaxKind::WhereKw,
69+
SyntaxKind::Arrow,
70+
SyntaxKind::LBrace,
71+
],
6172
);
6273

6374
parser.with_next_expected_tokens(
@@ -68,7 +79,7 @@ fn parse_normal_fn_def_impl<S: TokenStream>(parser: &mut Parser<S>, allow_self:
6879
parser.error_and_recover("expected `(` for the function arguments", None);
6980
}
7081
},
71-
&[SyntaxKind::LBrace, SyntaxKind::Arrow, SyntaxKind::WhereKw],
82+
&[SyntaxKind::Arrow, SyntaxKind::WhereKw, SyntaxKind::LBrace],
7283
);
7384

7485
parser.with_next_expected_tokens(

0 commit comments

Comments
 (0)