Skip to content

Commit 071c04c

Browse files
MilkeeyCatMilkeeyCat
committed
refactor(parser): parse_ident function & changed next_token to bump 
1 parent 9aabc87 commit 071c04c

File tree

1 file changed

+116
-113
lines changed

1 file changed

+116
-113
lines changed

‎src/parser/mod.rs

Lines changed: 116 additions & 113 deletions
Original file line numberDiff line numberDiff line change
@@ -92,24 +92,24 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
9292
]),
9393
};
9494

95-
parser.next_token()?;
96-
parser.next_token()?;
95+
parser.bump()?;
96+
parser.bump()?;
9797

9898
Ok(parser)
9999
}
100100

101-
fn next_token(&mut self) -> Result<Option<Token>, Error> {
101+
fn bump(&mut self) -> Result<(), Error> {
102102
match self.lexer.next().transpose() {
103103
Ok(mut token) => {
104104
std::mem::swap(&mut self.cur_token, &mut self.peek_token);
105105
std::mem::swap(&mut token, &mut self.peek_token);
106106

107-
Ok(token)
107+
Ok(())
108108
}
109109
Err(span) => {
110110
self.diag.error(Diagnostic::UnknownChar, span);
111111

112-
self.next_token()
112+
self.bump()
113113
}
114114
}
115115
}
@@ -123,9 +123,13 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
123123
}
124124

125125
fn expect(&mut self, token: &Token) -> Result<(), Error> {
126-
match self.next_token()? {
127-
Some(ref cur) if cur == token => Ok(()),
128-
Some(cur) => Err(Error::UnexpectedToken(token.to_owned(), cur)),
126+
match &self.cur_token {
127+
Some(cur) if cur == token => {
128+
self.bump()?;
129+
130+
Ok(())
131+
}
132+
Some(cur) => Err(Error::UnexpectedToken(token.to_owned(), cur.clone())),
129133
None => Err(Error::Expected(token.to_owned())),
130134
}
131135
}
@@ -174,16 +178,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
174178
fn parse_struct(&mut self) -> Result<Item, Error> {
175179
self.expect(&Token::Struct)?;
176180

177-
let name = match self
178-
.next_token()?
179-
.ok_or(Error::Expected(Token::Ident(Default::default())))?
180-
{
181-
Token::Ident(ident) => Ok(ident),
182-
token => Err(Error::UnexpectedToken(
183-
Token::Ident(Default::default()),
184-
token,
185-
)),
186-
}?;
181+
let name = self.parse_ident()?;
187182

188183
self.expect(&Token::LBrace)?;
189184

@@ -193,10 +188,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
193188
if self.cur_token_is(&Token::Fn) {
194189
// Handle struct methods here
195190
} else {
196-
let name = match self.next_token()? {
197-
Some(Token::Ident(ident)) => ident,
198-
_ => todo!("Don't know what error to return yet"),
199-
};
191+
let name = self.parse_ident()?;
200192
self.expect(&Token::Colon)?;
201193
let ty = self.parse_type()?;
202194

@@ -272,34 +264,39 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
272264
}
273265

274266
fn parse_type(&mut self) -> Result<Ty, Error> {
275-
Ok(match self.next_token()?.unwrap() {
276-
Token::Asterisk => Ty::Ptr(Box::new(self.parse_type()?)),
277-
Token::LBracket => match self.next_token()?.unwrap() {
278-
Token::Integer(int) => {
279-
let length: usize = str::parse(&int).unwrap();
280-
self.expect(&Token::RBracket)?;
281-
282-
Ty::Array {
283-
ty: Box::new(self.parse_type()?),
284-
len: length,
267+
let ty = match &self.cur_token {
268+
Some(Token::Asterisk) => Ty::Ptr(Box::new(self.parse_type()?)),
269+
Some(Token::LBracket) => {
270+
self.bump()?;
271+
272+
match &self.cur_token {
273+
Some(Token::Integer(int)) => {
274+
let length: usize = str::parse(int).unwrap();
275+
self.expect(&Token::RBracket)?;
276+
277+
Ty::Array {
278+
ty: Box::new(self.parse_type()?),
279+
len: length,
280+
}
285281
}
282+
token => panic!("Expected integer, got {token:?}"),
286283
}
287-
token => panic!("Expected integer, got {token}"),
288-
},
289-
Token::U8 => Ty::UInt(UintTy::U8),
290-
Token::U16 => Ty::UInt(UintTy::U16),
291-
Token::U32 => Ty::UInt(UintTy::U32),
292-
Token::U64 => Ty::UInt(UintTy::U64),
293-
Token::I8 => Ty::Int(IntTy::I8),
294-
Token::I16 => Ty::Int(IntTy::I16),
295-
Token::I32 => Ty::Int(IntTy::I32),
296-
Token::I64 => Ty::Int(IntTy::I64),
297-
Token::Usize => Ty::UInt(UintTy::Usize),
298-
Token::Isize => Ty::Int(IntTy::Isize),
299-
Token::Bool => Ty::Bool,
300-
Token::Void => Ty::Void,
301-
Token::Ident(ident) => Ty::Ident(ident),
302-
Token::Fn => {
284+
}
285+
Some(Token::U8) => Ty::UInt(UintTy::U8),
286+
Some(Token::U16) => Ty::UInt(UintTy::U16),
287+
Some(Token::U32) => Ty::UInt(UintTy::U32),
288+
Some(Token::U64) => Ty::UInt(UintTy::U64),
289+
Some(Token::I8) => Ty::Int(IntTy::I8),
290+
Some(Token::I16) => Ty::Int(IntTy::I16),
291+
Some(Token::I32) => Ty::Int(IntTy::I32),
292+
Some(Token::I64) => Ty::Int(IntTy::I64),
293+
Some(Token::Usize) => Ty::UInt(UintTy::Usize),
294+
Some(Token::Isize) => Ty::Int(IntTy::Isize),
295+
Some(Token::Bool) => Ty::Bool,
296+
Some(Token::Void) => Ty::Void,
297+
Some(Token::Ident(ident)) => Ty::Ident(ident.clone()),
298+
Some(Token::Fn) => {
299+
self.bump()?;
303300
self.expect(&Token::LParen)?;
304301

305302
let mut params = Vec::new();
@@ -315,10 +312,14 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
315312
self.expect(&Token::RParen)?;
316313
self.expect(&Token::Arrow)?;
317314

318-
Ty::Fn(params, Box::new(self.parse_type()?))
315+
return Ok(Ty::Fn(params, Box::new(self.parse_type()?)));
319316
}
320-
token => return Err(Error::ParseType(token)),
321-
})
317+
token => return Err(Error::ParseType(token.clone().unwrap())),
318+
};
319+
320+
self.bump()?;
321+
322+
Ok(ty)
322323
}
323324

324325
fn parse_return(&mut self) -> Result<Stmt, Error> {
@@ -405,12 +406,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
405406
fn local(&mut self) -> Result<Stmt, Error> {
406407
self.expect(&Token::Let)?;
407408

408-
let name = match self.next_token()?.unwrap() {
409-
Token::Ident(ident) => ident,
410-
token => {
411-
return Err(Error::ParseType(token));
412-
}
413-
};
409+
let name = self.parse_ident()?;
414410
let ty = if self.cur_token_is(&Token::Colon) {
415411
self.expect(&Token::Colon)?;
416412

@@ -439,12 +435,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
439435
fn global(&mut self) -> Result<Item, Error> {
440436
self.expect(&Token::Let)?;
441437

442-
let name = match self.next_token()?.unwrap() {
443-
Token::Ident(ident) => ident,
444-
token => {
445-
return Err(Error::ParseType(token));
446-
}
447-
};
438+
let name = self.parse_ident()?;
448439
self.expect(&Token::Colon)?;
449440

450441
let ty = self.parse_type()?;
@@ -469,12 +460,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
469460
fn function(&mut self, func_definition: bool) -> Result<Item, Error> {
470461
self.expect(&Token::Fn)?;
471462

472-
let name = match self.next_token()?.unwrap() {
473-
Token::Ident(ident) => ident,
474-
token => {
475-
return Err(Error::ParseType(token));
476-
}
477-
};
463+
let name = self.parse_ident()?;
478464

479465
self.expect(&Token::LParen)?;
480466

@@ -508,10 +494,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
508494
let mut params = Vec::new();
509495

510496
while !self.cur_token_is(&end) {
511-
let name = match self.next_token()? {
512-
Some(Token::Ident(ident)) => ident,
513-
_ => todo!("Don't know what error to return yet"),
514-
};
497+
let name = self.parse_ident()?;
515498
self.expect(&Token::Colon)?;
516499
let type_ = self.parse_type()?;
517500

@@ -533,28 +516,20 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
533516
fn ident(&mut self) -> Result<Expr, Error> {
534517
match self.peek_token {
535518
Some(Token::LBrace) => self.struct_expr(),
536-
_ => match self
537-
.next_token()?
538-
.ok_or(Error::Expected(Token::Ident(Default::default())))?
539-
{
540-
Token::Ident(ident) => Ok(Expr::Ident(ExprIdent(ident))),
541-
token => Err(Error::ParseType(token)),
542-
},
519+
_ => Ok(Expr::Ident(ExprIdent(self.parse_ident()?))),
543520
}
544521
}
545522

546523
fn struct_expr(&mut self) -> Result<Expr, Error> {
547-
let name = match self.next_token()? {
548-
Some(Token::Ident(ident)) => ident,
549-
_ => todo!("Don't know what error to return yet"),
550-
};
524+
let name = self.parse_ident()?;
551525

552526
self.expect(&Token::LBrace)?;
553527
let mut fields = Vec::new();
554528

555529
while !self.cur_token_is(&Token::RBrace) {
556-
match self.next_token()? {
530+
match self.cur_token.clone() {
557531
Some(Token::Ident(field)) => {
532+
self.bump()?;
558533
self.expect(&Token::Colon)?;
559534
let expr = self.expr(Precedence::Lowest)?;
560535

@@ -574,16 +549,26 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
574549
}
575550

576551
fn string_lit(&mut self) -> Result<Expr, Error> {
577-
match self.next_token()? {
578-
Some(Token::String(literal)) => Ok(Expr::Lit(ExprLit::String(literal))),
579-
Some(_) | None => unreachable!(),
552+
match &self.cur_token {
553+
Some(Token::String(literal)) => {
554+
let lit = literal.clone();
555+
self.bump()?;
556+
557+
Ok(Expr::Lit(ExprLit::String(lit)))
558+
}
559+
_ => unreachable!(),
580560
}
581561
}
582562

583563
fn int_lit(&mut self) -> Result<Expr, Error> {
584-
match self.next_token()? {
585-
Some(Token::Integer(num_str)) => Ok(Expr::Lit(ExprLit::UInt(num_str.parse().unwrap()))),
586-
Some(_) | None => unreachable!(),
564+
match &self.cur_token {
565+
Some(Token::Integer(num_str)) => {
566+
let lit = num_str.parse().unwrap();
567+
self.bump()?;
568+
569+
Ok(Expr::Lit(ExprLit::UInt(lit)))
570+
}
571+
_ => unreachable!(),
587572
}
588573
}
589574

@@ -594,10 +579,18 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
594579
}
595580

596581
fn bool(&mut self) -> Result<Expr, Error> {
597-
match self.next_token()? {
598-
Some(Token::True) => Ok(Expr::Lit(ExprLit::Bool(true))),
599-
Some(Token::False) => Ok(Expr::Lit(ExprLit::Bool(false))),
600-
Some(_) | None => unreachable!(),
582+
match &self.cur_token {
583+
Some(Token::True) => {
584+
self.bump()?;
585+
586+
Ok(Expr::Lit(ExprLit::Bool(true)))
587+
}
588+
Some(Token::False) => {
589+
self.bump()?;
590+
591+
Ok(Expr::Lit(ExprLit::Bool(false)))
592+
}
593+
_ => unreachable!(),
601594
}
602595
}
603596

@@ -624,7 +617,12 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
624617
let mut tokens = Vec::new();
625618

626619
while !self.cur_token_is(&Token::RParen) {
627-
tokens.push(self.next_token()?.ok_or(Error::Expected(Token::RParen))?);
620+
tokens.push(
621+
self.cur_token
622+
.clone()
623+
.ok_or(Error::Expected(Token::RParen))?,
624+
);
625+
self.bump()?;
628626
}
629627

630628
self.expect(&Token::RParen)?;
@@ -633,7 +631,8 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
633631
}
634632

635633
fn bin_expr(&mut self, left: Expr) -> Result<Expr, Error> {
636-
let token = self.next_token()?.unwrap();
634+
let token = self.cur_token.clone().unwrap();
635+
self.bump()?;
637636

638637
// NOTE: assignment expression is right-associative
639638
let precedence = if let &Token::Assign = &token {
@@ -654,10 +653,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
654653
fn pointer_access(&mut self, left: Expr) -> Result<Expr, Error> {
655654
self.expect(&Token::Arrow)?;
656655

657-
let field = match self.next_token()? {
658-
Some(Token::Ident(ident)) => ident,
659-
_ => unreachable!(),
660-
};
656+
let field = self.parse_ident()?;
661657

662658
Ok(Expr::Field(ExprField {
663659
expr: Box::new(Expr::Unary(ExprUnary {
@@ -672,10 +668,7 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
672668
self.expect(&Token::Period)?;
673669

674670
if self.peek_token_is(&Token::LParen) {
675-
let method = match self.next_token()? {
676-
Some(Token::Ident(field)) => field,
677-
_ => panic!("Struct field name should be of type string"),
678-
};
671+
let method = self.parse_ident()?;
679672

680673
self.expect(&Token::LParen)?;
681674
let arguments = self.expr_list()?;
@@ -686,13 +679,10 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
686679
arguments,
687680
}))
688681
} else {
689-
match self.next_token()? {
690-
Some(Token::Ident(field)) => Ok(Expr::Field(ExprField {
691-
expr: Box::new(expr),
692-
field,
693-
})),
694-
_ => panic!("Struct field name should be of type string"),
695-
}
682+
Ok(Expr::Field(ExprField {
683+
expr: Box::new(expr),
684+
field: self.parse_ident()?,
685+
}))
696686
}
697687
}
698688

@@ -717,7 +707,9 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
717707
}
718708

719709
fn unary_expr(&mut self) -> Result<Expr, Error> {
720-
let op = UnOp::try_from(&self.next_token()?.unwrap()).map_err(|e| Error::Operator(e))?;
710+
let token = self.cur_token.clone().unwrap();
711+
self.bump()?;
712+
let op = UnOp::try_from(&token).map_err(|e| Error::Operator(e))?;
721713
let expr = self.expr(Precedence::Prefix)?;
722714

723715
Ok(Expr::Unary(ExprUnary {
@@ -766,6 +758,17 @@ impl<'a, 'src, T: Iterator<Item = Result<Token, Span>>> Parser<'a, 'src, T> {
766758

767759
Ok(Expr::Array(ExprArray(items)))
768760
}
761+
762+
fn parse_ident(&mut self) -> Result<String, Error> {
763+
match self.cur_token.clone() {
764+
Some(Token::Ident(ident)) => {
765+
self.bump()?;
766+
767+
Ok(ident)
768+
}
769+
_ => todo!(),
770+
}
771+
}
769772
}
770773

771774
#[cfg(test)]

0 commit comments

Comments
 (0)