Skip to content

Commit 7ff95bc

Browse files
MilkeeyCatMilkeeyCat
committed
refactor(parser/bump): remove return type
1 parent 8113def commit 7ff95bc

File tree

2 files changed

+35
-39
lines changed

2 files changed

+35
-39
lines changed

‎src/compile.rs

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -54,11 +54,8 @@ pub fn compile(args: CompileArgs) -> Result<(), Box<dyn std::error::Error>> {
5454

5555
let mut diagnostics = Diagnostics::new(&source_code);
5656
let lexer = Lexer::new(&source_code);
57-
let ast = match parser::Parser::new(lexer, &mut diagnostics) {
58-
Ok(mut parser) => match parser.parse() {
59-
Ok(ast) => ast,
60-
Err(_) => report_diag_and_exit(&diagnostics),
61-
},
57+
let ast = match parser::Parser::new(lexer, &mut diagnostics).parse() {
58+
Ok(ast) => ast,
6259
Err(_) => report_diag_and_exit(&diagnostics),
6360
};
6461

‎src/parser/mod.rs

Lines changed: 33 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ pub struct Parser<'a, 'src, T: Iterator<Item = Result<Token, Span>>> {
2424
}
2525

2626
impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
27-
pub fn new(lexer: T, diag: &'a mut Diagnostics<'src>) -> Result<Self, ()> {
27+
pub fn new(lexer: T, diag: &'a mut Diagnostics<'src>) -> Self {
2828
let mut parser = Self {
2929
prev_token: None,
3030
cur_token: None,
@@ -83,20 +83,18 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
8383
]),
8484
};
8585

86-
parser.bump()?;
87-
parser.bump()?;
86+
parser.bump();
87+
parser.bump();
8888

89-
Ok(parser)
89+
parser
9090
}
9191

92-
fn bump(&mut self) -> Result<(), ()> {
92+
fn bump(&mut self) {
9393
match self.lexer.next().transpose() {
9494
Ok(mut token) => {
9595
std::mem::swap(&mut self.prev_token, &mut self.cur_token);
9696
std::mem::swap(&mut self.cur_token, &mut self.peek_token);
9797
std::mem::swap(&mut token, &mut self.peek_token);
98-
99-
Ok(())
10098
}
10199
Err(span) => {
102100
self.diag.error(Diagnostic::UnknownChar, span);
@@ -118,7 +116,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
118116
match &self.cur_token {
119117
Some(cur) if &cur.kind == kind => {
120118
let span = cur.span.clone();
121-
self.bump()?;
119+
self.bump();
122120

123121
Ok(span)
124122
}
@@ -135,13 +133,12 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
135133

136134
while let Some(token) = &self.cur_token {
137135
let item = match token.kind {
138-
TokenKind::Struct => Some(self.parse_struct_item()?),
139-
TokenKind::Let => Some(self.parse_global_item()?),
140-
TokenKind::Fn => Some(self.parse_function_item(true)?),
136+
TokenKind::Struct => self.parse_struct_item().ok(),
137+
TokenKind::Let => self.parse_global_item().ok(),
138+
TokenKind::Fn => self.parse_function_item(true).ok(),
141139
_ => {
142140
self.expected(&[&TokenKind::Struct, &TokenKind::Let, &TokenKind::Fn]);
143-
144-
self.bump()?;
141+
self.bump();
145142

146143
None
147144
}
@@ -266,7 +263,9 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
266263
let open_brace = self.expect(&TokenKind::LBrace)?;
267264

268265
while !self.cur_token_is(&TokenKind::RBrace) {
269-
stmts.push(self.parse_stmt()?);
266+
if let Ok(stmt) = self.parse_stmt() {
267+
stmts.push(stmt);
268+
}
270269
}
271270

272271
let close_brace = self.expect(&TokenKind::RBrace)?;
@@ -295,7 +294,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
295294
let ty = match self.cur_token.as_ref().map(|token| &token.kind) {
296295
Some(TokenKind::Asterisk) => Ty::Ptr(Box::new(self.parse_type()?)),
297296
Some(TokenKind::LBracket) => {
298-
self.bump()?;
297+
self.bump();
299298

300299
match &self.cur_token {
301300
Some(Token {
@@ -307,7 +306,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
307306
Err(_) => {
308307
let span = span.clone();
309308

310-
self.bump()?;
309+
self.bump();
311310
self.diag.error(Diagnostic::IntegerLitralTooLong, span);
312311

313312
return Err(());
@@ -322,7 +321,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
322321
}
323322
_ => {
324323
self.expected(&[&TokenKind::Integer(Default::default())]);
325-
self.bump()?;
324+
self.bump();
326325

327326
return Err(())?;
328327
}
@@ -342,7 +341,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
342341
Some(TokenKind::Void) => Ty::Void,
343342
Some(TokenKind::Ident(ident)) => Ty::Ident(ident.clone()),
344343
Some(TokenKind::Fn) => {
345-
self.bump()?;
344+
self.bump();
346345
self.expect(&TokenKind::LParen)?;
347346

348347
let mut params = Vec::new();
@@ -371,13 +370,13 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
371370
})
372371
.clone(),
373372
);
374-
self.bump()?;
373+
self.bump();
375374

376375
return Err(());
377376
}
378377
};
379378

380-
self.bump()?;
379+
self.bump();
381380

382381
Ok(ty)
383382
}
@@ -615,13 +614,13 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
615614
..
616615
}) => {
617616
let lit = literal.clone();
618-
self.bump()?;
617+
self.bump();
619618

620619
Ok(Expr::Lit(ExprLit::String(lit)))
621620
}
622621
_ => {
623622
self.expected(&[&TokenKind::String(Default::default())]);
624-
self.bump()?;
623+
self.bump();
625624

626625
Err(())
627626
}
@@ -641,18 +640,18 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
641640
fn parse_bool_expr(&mut self) -> Result<Expr, ()> {
642641
match self.cur_token.as_ref().map(|token| &token.kind) {
643642
Some(TokenKind::True) => {
644-
self.bump()?;
643+
self.bump();
645644

646645
Ok(Expr::Lit(ExprLit::Bool(true)))
647646
}
648647
Some(TokenKind::False) => {
649-
self.bump()?;
648+
self.bump();
650649

651650
Ok(Expr::Lit(ExprLit::Bool(false)))
652651
}
653652
_ => {
654653
self.expected(&[&TokenKind::True, &TokenKind::False]);
655-
self.bump()?;
654+
self.bump();
656655

657656
Err(())
658657
}
@@ -687,7 +686,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
687686

688687
()
689688
})?);
690-
self.bump()?;
689+
self.bump();
691690
}
692691

693692
self.expect(&TokenKind::RParen)?;
@@ -697,7 +696,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
697696

698697
fn parse_bin_expr(&mut self, left: Expr) -> Result<Expr, ()> {
699698
let token = self.cur_token_unchecked();
700-
self.bump()?;
699+
self.bump();
701700

702701
// NOTE: assignment expression is right-associative
703702
let precedence = if let &TokenKind::Assign = &token.kind {
@@ -776,7 +775,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
776775

777776
fn parse_unary_expr(&mut self) -> Result<Expr, ()> {
778777
let token = self.cur_token_unchecked();
779-
self.bump()?;
778+
self.bump();
780779
let op = UnOp::try_from(&token.kind).map_err(|_| {
781780
self.diag
782781
.error(Diagnostic::ExpressionInfix(token.kind), token.span);
@@ -841,19 +840,19 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
841840
Err(_) => {
842841
let span = span.clone();
843842

844-
self.bump()?;
843+
self.bump();
845844
self.diag.error(Diagnostic::IntegerLitralTooLong, span);
846845

847846
return Err(());
848847
}
849848
};
850-
self.bump()?;
849+
self.bump();
851850

852851
Ok(lit)
853852
}
854853
_ => {
855854
self.expected(&[&TokenKind::Integer(Default::default())]);
856-
self.bump()?;
855+
self.bump();
857856

858857
Err(())
859858
}
@@ -866,13 +865,13 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
866865
kind: TokenKind::Ident(ident),
867866
span,
868867
}) => {
869-
self.bump()?;
868+
self.bump();
870869

871870
Ok((ident, span))
872871
}
873872
_ => {
874873
self.expected(&[&TokenKind::Ident(Default::default())]);
875-
self.bump()?;
874+
self.bump();
876875

877876
Err(())
878877
}
@@ -1050,7 +1049,7 @@ mod test {
10501049

10511050
for (input, expected) in tests {
10521051
let mut diagnostics = Diagnostics::new(input);
1053-
let mut parser = Parser::new(Lexer::new(input), &mut diagnostics).unwrap();
1052+
let mut parser = Parser::new(Lexer::new(input), &mut diagnostics);
10541053
let ast = parser.parse_block_stmt().unwrap();
10551054

10561055
assert_eq!(

0 commit comments

Comments
 (0)