refactor(tazjin/rlox): Let Parser::match_token take a single kind
This is much easier to read & write. It's been annoying me all the way through. Change-Id: Ia91756d3111a2ce3f74e1c14bccc210118d221dd Reviewed-on: https://cl.tvl.fyi/c/depot/+/2387 Reviewed-by: tazjin <mail@tazj.in> Tested-by: BuildkiteCI
This commit is contained in:
		
							parent
							
								
									f4a6e9f133
								
							
						
					
					
						commit
						fcd9801b01
					
				
					 1 changed files with 22 additions and 24 deletions
				
			
		| 
						 | 
					@ -159,7 +159,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
    // recursive-descent parser functions
 | 
					    // recursive-descent parser functions
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    fn declaration(&mut self) -> StmtResult<'a> {
 | 
					    fn declaration(&mut self) -> StmtResult<'a> {
 | 
				
			||||||
        if self.match_token(&[TokenKind::Var]) {
 | 
					        if self.match_token(&TokenKind::Var) {
 | 
				
			||||||
            return self.var_declaration();
 | 
					            return self.var_declaration();
 | 
				
			||||||
        }
 | 
					        }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
| 
						 | 
					@ -175,7 +175,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
                initialiser: None,
 | 
					                initialiser: None,
 | 
				
			||||||
            };
 | 
					            };
 | 
				
			||||||
 | 
					
 | 
				
			||||||
            if self.match_token(&[TokenKind::Equal]) {
 | 
					            if self.match_token(&TokenKind::Equal) {
 | 
				
			||||||
                var.initialiser = Some(self.expression()?);
 | 
					                var.initialiser = Some(self.expression()?);
 | 
				
			||||||
            }
 | 
					            }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
| 
						 | 
					@ -190,15 +190,15 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
    }
 | 
					    }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    fn statement(&mut self) -> StmtResult<'a> {
 | 
					    fn statement(&mut self) -> StmtResult<'a> {
 | 
				
			||||||
        if self.match_token(&[TokenKind::Print]) {
 | 
					        if self.match_token(&TokenKind::Print) {
 | 
				
			||||||
            self.print_statement()
 | 
					            self.print_statement()
 | 
				
			||||||
        } else if self.match_token(&[TokenKind::LeftBrace]) {
 | 
					        } else if self.match_token(&TokenKind::LeftBrace) {
 | 
				
			||||||
            self.block_statement()
 | 
					            self.block_statement()
 | 
				
			||||||
        } else if self.match_token(&[TokenKind::If]) {
 | 
					        } else if self.match_token(&TokenKind::If) {
 | 
				
			||||||
            self.if_statement()
 | 
					            self.if_statement()
 | 
				
			||||||
        } else if self.match_token(&[TokenKind::While]) {
 | 
					        } else if self.match_token(&TokenKind::While) {
 | 
				
			||||||
            self.while_statement()
 | 
					            self.while_statement()
 | 
				
			||||||
        } else if self.match_token(&[TokenKind::For]) {
 | 
					        } else if self.match_token(&TokenKind::For) {
 | 
				
			||||||
            self.for_statement()
 | 
					            self.for_statement()
 | 
				
			||||||
        } else {
 | 
					        } else {
 | 
				
			||||||
            self.expr_statement()
 | 
					            self.expr_statement()
 | 
				
			||||||
| 
						 | 
					@ -242,7 +242,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
            else_branch: Option::None,
 | 
					            else_branch: Option::None,
 | 
				
			||||||
        };
 | 
					        };
 | 
				
			||||||
 | 
					
 | 
				
			||||||
        if self.match_token(&[TokenKind::Else]) {
 | 
					        if self.match_token(&TokenKind::Else) {
 | 
				
			||||||
            stmt.else_branch = Some(Box::new(self.statement()?));
 | 
					            stmt.else_branch = Some(Box::new(self.statement()?));
 | 
				
			||||||
        }
 | 
					        }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
| 
						 | 
					@ -275,9 +275,9 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
            ErrorKind::ExpectedToken("Expected '(' after 'for'"),
 | 
					            ErrorKind::ExpectedToken("Expected '(' after 'for'"),
 | 
				
			||||||
        )?;
 | 
					        )?;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
        let initialiser = if self.match_token(&[TokenKind::Semicolon]) {
 | 
					        let initialiser = if self.match_token(&TokenKind::Semicolon) {
 | 
				
			||||||
            None
 | 
					            None
 | 
				
			||||||
        } else if self.match_token(&[TokenKind::Var]) {
 | 
					        } else if self.match_token(&TokenKind::Var) {
 | 
				
			||||||
            Some(self.var_declaration()?)
 | 
					            Some(self.var_declaration()?)
 | 
				
			||||||
        } else {
 | 
					        } else {
 | 
				
			||||||
            Some(self.expr_statement()?)
 | 
					            Some(self.expr_statement()?)
 | 
				
			||||||
| 
						 | 
					@ -336,7 +336,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
    fn assignment(&mut self) -> ExprResult<'a> {
 | 
					    fn assignment(&mut self) -> ExprResult<'a> {
 | 
				
			||||||
        let expr = self.logic_or()?;
 | 
					        let expr = self.logic_or()?;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
        if self.match_token(&[TokenKind::Equal]) {
 | 
					        if self.match_token(&TokenKind::Equal) {
 | 
				
			||||||
            let equals = self.previous().clone();
 | 
					            let equals = self.previous().clone();
 | 
				
			||||||
            let value = self.assignment()?;
 | 
					            let value = self.assignment()?;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
| 
						 | 
					@ -359,7 +359,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
    fn logic_or(&mut self) -> ExprResult<'a> {
 | 
					    fn logic_or(&mut self) -> ExprResult<'a> {
 | 
				
			||||||
        let mut expr = self.logic_and()?;
 | 
					        let mut expr = self.logic_and()?;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
        while self.match_token(&[TokenKind::Or]) {
 | 
					        while self.match_token(&TokenKind::Or) {
 | 
				
			||||||
            expr = Expr::Logical(Logical {
 | 
					            expr = Expr::Logical(Logical {
 | 
				
			||||||
                left: Box::new(expr),
 | 
					                left: Box::new(expr),
 | 
				
			||||||
                operator: self.previous().clone(),
 | 
					                operator: self.previous().clone(),
 | 
				
			||||||
| 
						 | 
					@ -373,7 +373,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
    fn logic_and(&mut self) -> ExprResult<'a> {
 | 
					    fn logic_and(&mut self) -> ExprResult<'a> {
 | 
				
			||||||
        let mut expr = self.equality()?;
 | 
					        let mut expr = self.equality()?;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
        while self.match_token(&[TokenKind::And]) {
 | 
					        while self.match_token(&TokenKind::And) {
 | 
				
			||||||
            expr = Expr::Logical(Logical {
 | 
					            expr = Expr::Logical(Logical {
 | 
				
			||||||
                left: Box::new(expr),
 | 
					                left: Box::new(expr),
 | 
				
			||||||
                operator: self.previous().clone(),
 | 
					                operator: self.previous().clone(),
 | 
				
			||||||
| 
						 | 
					@ -412,7 +412,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
    }
 | 
					    }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    fn unary(&mut self) -> ExprResult<'a> {
 | 
					    fn unary(&mut self) -> ExprResult<'a> {
 | 
				
			||||||
        if self.match_token(&[TokenKind::Bang, TokenKind::Minus]) {
 | 
					        if self.match_token(&TokenKind::Bang) || self.match_token(&TokenKind::Minus) {
 | 
				
			||||||
            return Ok(Expr::Unary(Unary {
 | 
					            return Ok(Expr::Unary(Unary {
 | 
				
			||||||
                operator: self.previous().clone(),
 | 
					                operator: self.previous().clone(),
 | 
				
			||||||
                right: Box::new(self.unary()?),
 | 
					                right: Box::new(self.unary()?),
 | 
				
			||||||
| 
						 | 
					@ -426,7 +426,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
        let mut expr = self.primary()?;
 | 
					        let mut expr = self.primary()?;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
        loop {
 | 
					        loop {
 | 
				
			||||||
            if self.match_token(&[TokenKind::LeftParen]) {
 | 
					            if self.match_token(&TokenKind::LeftParen) {
 | 
				
			||||||
                expr = self.finish_call(expr)?;
 | 
					                expr = self.finish_call(expr)?;
 | 
				
			||||||
            } else {
 | 
					            } else {
 | 
				
			||||||
                break;
 | 
					                break;
 | 
				
			||||||
| 
						 | 
					@ -443,7 +443,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
            loop {
 | 
					            loop {
 | 
				
			||||||
                // TODO(tazjin): Check for max args count
 | 
					                // TODO(tazjin): Check for max args count
 | 
				
			||||||
                args.push(self.expression()?);
 | 
					                args.push(self.expression()?);
 | 
				
			||||||
                if !self.match_token(&[TokenKind::Comma]) {
 | 
					                if !self.match_token(&TokenKind::Comma) {
 | 
				
			||||||
                    break;
 | 
					                    break;
 | 
				
			||||||
                }
 | 
					                }
 | 
				
			||||||
            }
 | 
					            }
 | 
				
			||||||
| 
						 | 
					@ -493,15 +493,13 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
    // internal helpers
 | 
					    // internal helpers
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    /// Check if the next token is in `oneof`, and advance if it is.
 | 
					    /// Check if the next token is in `oneof`, and advance if it is.
 | 
				
			||||||
    fn match_token(&mut self, oneof: &[TokenKind]) -> bool {
 | 
					    fn match_token(&mut self, token: &TokenKind) -> bool {
 | 
				
			||||||
        for token in oneof {
 | 
					        if self.check_token(token) {
 | 
				
			||||||
            if self.check_token(token) {
 | 
					            self.advance();
 | 
				
			||||||
                self.advance();
 | 
					            return true;
 | 
				
			||||||
                return true;
 | 
					 | 
				
			||||||
            }
 | 
					 | 
				
			||||||
        }
 | 
					        }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
        return false;
 | 
					        false
 | 
				
			||||||
    }
 | 
					    }
 | 
				
			||||||
 | 
					
 | 
				
			||||||
    /// Return the next token and advance parser state.
 | 
					    /// Return the next token and advance parser state.
 | 
				
			||||||
| 
						 | 
					@ -573,7 +571,7 @@ impl<'a> Parser<'a> {
 | 
				
			||||||
    ) -> ExprResult<'a> {
 | 
					    ) -> ExprResult<'a> {
 | 
				
			||||||
        let mut expr = each(self)?;
 | 
					        let mut expr = each(self)?;
 | 
				
			||||||
 | 
					
 | 
				
			||||||
        while self.match_token(oneof) {
 | 
					        while oneof.iter().any(|t| self.match_token(t)) {
 | 
				
			||||||
            expr = Expr::Binary(Binary {
 | 
					            expr = Expr::Binary(Binary {
 | 
				
			||||||
                left: Box::new(expr),
 | 
					                left: Box::new(expr),
 | 
				
			||||||
                operator: self.previous().clone(),
 | 
					                operator: self.previous().clone(),
 | 
				
			||||||
| 
						 | 
					
 | 
				
			||||||
		Loading…
	
	Add table
		Add a link
		
	
		Reference in a new issue