rlox/src/frontend/parser.rs

use crate::{
    frontend::{
        ast::{AstNode, Expr, Stmt},
        tokens::{LiteralValue, Token, TokenType},
    },
    logging::display_ast::{pretty_print_with_config, PrettyConfig, PrettyPrint},
    result::{LoxError, LoxResult},
};

pub struct Parser {
    tokens: Vec<Token>,
    current: usize,
}

impl Parser {
    pub fn new(tokens: Vec<Token>) -> Self {
        Self { tokens, current: 0 }
    }

    pub fn parse(&mut self) -> LoxResult<Vec<AstNode<Stmt>>> {
        let mut statements = Vec::new();
        let mut errors = Vec::new();
        println!("\n \n ++++++++++++++++++++++++++++++++++++\nStarting parsing");
        // Con configurazione personalizzata
        let config = PrettyConfig {
            indent: "    ".to_string(),
            max_depth: None,
            show_positions: false,
            ..Default::default()
        };
        while !self.is_at_end() {
            match self.statement() {
                Ok(stmt) => {
                    println!(
                        "Parsed Successfully: {}",
                        pretty_print_with_config(&stmt.node, &config)
                    );

                    statements.push(stmt.clone());
                }
                Err(err) => {
                    println!("Error: {:?}", err);
                    errors.push(err);
                    let old_current = self.current;
                    self.synchronize();
                    println!("Synchronized from {} to {}", old_current, self.current);
                }
            }
        }

        if !errors.is_empty() {
            return Err(errors.into_iter().next().unwrap());
        }

        Ok(statements)
    }

    fn statement(&mut self) -> LoxResult<AstNode<Stmt>> {
        match (&self.peek().token_type, &self.peek_next().token_type) {
            (TokenType::Var, _) => Ok(AstNode::new(
                self.var_statement()?,
                self.peek().source_slice.clone(),
            )),
            (TokenType::Print, _) => Ok(AstNode::new(
                self.print_statement()?,
                self.peek().source_slice.clone(),
            )),
            (TokenType::Return, _) => Ok(AstNode::new(
                self.return_statement()?,
                self.peek().source_slice.clone(),
            )),
            (TokenType::StartBlock, _) => Ok(AstNode::new(
                self.block_statement()?,
                self.peek().source_slice.clone(),
            )),
            (TokenType::Identifier, TokenType::Equal) => Ok(AstNode::new(
                self.assignment_statement()?,
                self.peek().source_slice.clone(),
            )),
            (TokenType::If, _) => Ok(AstNode::new(
                self.if_statement()?,
                self.peek().source_slice.clone(),
            )),
            (TokenType::While, _) => Ok(AstNode::new(
                self.while_statement()?,
                self.peek().source_slice.clone(),
            )),
            _ => Ok(AstNode::new(
                self.expression_statement()?,
                self.peek().source_slice.clone(),
            )),
        }
    }

    fn while_statement(&mut self) -> LoxResult<Stmt> {
        self.advance();
        let condition = self.expression()?;
        let body = self.block_statement()?;
        Ok(Stmt::While {
            condition: Box::new(condition),
            body: Box::new(body),
        })
    }

    fn if_statement(&mut self) -> LoxResult<Stmt> {
        self.advance();
        let condition = self.expression()?;
        let then_branch = self.statement()?;
        let mut elif_branches = Vec::new();
        while self.peek().token_type == TokenType::Elif {
            self.advance();
            let condition = self.expression()?;
            let then_branch = self.statement()?;
            elif_branches.push((Box::new(condition), Box::new(then_branch.node)));
        }
        let else_branch = if self.peek().token_type == TokenType::Else {
            self.advance();
            Some(Box::new(self.statement()?.node))
        } else {
            None
        };
        Ok(Stmt::If {
            condition: Box::new(condition),
            then_branch: Box::new(then_branch.node),
            elif_branch: elif_branches,
            else_branch: else_branch,
        })
    }

    fn var_statement(&mut self) -> LoxResult<Stmt> {
        self.advance();
        let name = self.consume(TokenType::Identifier, "Expect variable name.")?;
        let name_lexeme = name.lexeme.clone();
        self.consume(TokenType::Equal, "Expect '=' after variable name.")?;
        let value = self.expression()?;
        self.consume(
            TokenType::Semicolon,
            "Expect ';' after variable declaration.",
        )?;
        Ok(Stmt::Var {
            name: name_lexeme,
            initializer: Some(Box::new(value)),
        })
    }

    fn assignment_statement(&mut self) -> LoxResult<Stmt> {
        let name = self.consume(TokenType::Identifier, "Expect variable name.")?;
        let name_lexeme = name.lexeme.clone();
        self.consume(TokenType::Equal, "Expect '=' after variable name.")?;
        let value = self.expression()?;
        self.consume(
            TokenType::Semicolon,
            "Expect ';' after variable declaration.",
        )?;
        Ok(Stmt::Assign {
            name: name_lexeme,
            value: Box::new(value),
        })
    }

    fn print_statement(&mut self) -> LoxResult<Stmt> {
        // consume the print keyword
        self.advance();
        let expr = self.expression()?;
        self.consume(TokenType::Semicolon, "Expect ';' after value.")?;
        Ok(Stmt::Print {
            expression: Box::new(expr),
        })
    }

    fn block_statement(&mut self) -> LoxResult<Stmt> {
        self.advance();
        let mut statements = Vec::new();
        while self.peek().token_type != TokenType::EndBlock && !self.is_at_end() {
            let stmt = self.statement()?;
            statements.push(stmt.node.clone());
            if let Stmt::Expression { .. } = stmt.node {
                break;
            }
        }
        self.consume(TokenType::EndBlock, "Expect 'end' after block.")?;
        Ok(Stmt::Block {
            statements: Box::new(statements),
        })
    }

    fn expression_statement(&mut self) -> LoxResult<Stmt> {
        let expr = self.expression()?;
        if self.peek().token_type == TokenType::Semicolon {
            self.advance();
            return Ok(Stmt::Stmt {
                expression: Box::new(expr),
            });
        }
        Ok(Stmt::Expression {
            expression: Box::new(expr),
        })
    }

    fn return_statement(&mut self) -> LoxResult<Stmt> {
        self.advance();
        let expr = self.expression()?;
        self.consume(TokenType::Semicolon, "Expect ';' after return value.")?;
        Ok(Stmt::Return {
            expression: Box::new(expr),
        })
    }

    fn expression(&mut self) -> LoxResult<Expr> {
        self.or_and()
    }

    fn or_and(&mut self) -> LoxResult<Expr> {
        let mut expr = self.equality()?;

        while [TokenType::Or, TokenType::And].contains(&self.peek().token_type) {
            let operator = self.peek().token_type.clone();
            self.advance();
            let right = self.equality()?;
            expr = Expr::Binary {
                left: Box::new(expr),
                operator,
                right: Box::new(right),
            };
        }

        Ok(expr)
    }
    fn equality(&mut self) -> LoxResult<Expr> {
        let mut expr = self.comparison()?;

        while [TokenType::BangEqual, TokenType::EqualEqual].contains(&self.peek().token_type) {
            let operator = self.peek().token_type.clone();
            self.advance();
            let right = self.comparison()?;
            expr = Expr::Binary {
                left: Box::new(expr),
                operator,
                right: Box::new(right),
            };
        }

        Ok(expr)
    }

    fn comparison(&mut self) -> LoxResult<Expr> {
        let mut expr = self.term()?;

        while [
            TokenType::Greater,
            TokenType::GreaterEqual,
            TokenType::Less,
            TokenType::LessEqual,
        ]
        .contains(&self.peek().token_type)
        {
            let operator = self.peek().token_type.clone();
            self.advance();
            let right = self.term()?;
            expr = Expr::Binary {
                left: Box::new(expr),
                operator,
                right: Box::new(right),
            };
        }

        Ok(expr)
    }

    fn term(&mut self) -> LoxResult<Expr> {
        let mut expr = self.factor()?;

        while [TokenType::Plus, TokenType::Minus].contains(&self.peek().token_type) {
            let operator = self.peek().token_type.clone();
            self.advance();
            let right = self.factor()?;
            expr = Expr::Binary {
                left: Box::new(expr),
                operator,
                right: Box::new(right),
            };
        }

        Ok(expr)
    }

    fn factor(&mut self) -> LoxResult<Expr> {
        let mut expr = self.unary()?;

        while [TokenType::Slash, TokenType::Star].contains(&self.peek().token_type) {
            let operator = self.peek().token_type.clone();
            self.advance();
            let right = self.unary()?;
            expr = Expr::Binary {
                left: Box::new(expr),
                operator,
                right: Box::new(right),
            };
        }

        Ok(expr)
    }

    fn unary(&mut self) -> LoxResult<Expr> {
        if [TokenType::Bang, TokenType::Minus].contains(&self.peek().token_type) {
            let operator = self.peek().token_type.clone();
            self.advance();
            let right = self.unary()?;
            return Ok(Expr::Unary {
                operator,
                operand: Box::new(right),
            });
        }

        self.primary()
    }

    fn primary(&mut self) -> LoxResult<Expr> {
        match self.peek().token_type {
            TokenType::False => {
                self.advance();
                Ok(Expr::Literal {
                    value: LiteralValue::Boolean(false),
                })
            }
            TokenType::True => {
                self.advance();
                Ok(Expr::Literal {
                    value: LiteralValue::Boolean(true),
                })
            }
            TokenType::Nil => {
                self.advance();
                Ok(Expr::Literal {
                    value: LiteralValue::Nil,
                })
            }
            TokenType::Number => {
                self.advance();
                let token = self.previous();
                if let Some(literal) = &token.literal {
                    Ok(Expr::Literal {
                        value: literal.clone(),
                    })
                } else {
                    Err(self.error(token, "Expected number literal").into())
                }
            }
            TokenType::String => {
                self.advance();
                let token = self.previous();
                if let Some(literal) = &token.literal {
                    Ok(Expr::Literal {
                        value: literal.clone(),
                    })
                } else {
                    Err(self.error(token, "Expected string literal").into())
                }
            }
            TokenType::LeftParen => {
                self.advance();
                let expr = self.expression()?;
                self.consume(TokenType::RightParen, "Expect ')' after expression.")?;
                Ok(Expr::Grouping {
                    expression: Box::new(expr),
                })
            }
            TokenType::Identifier => {
                let name = self.peek().lexeme.clone();
                self.advance();
                Ok(Expr::Variable { name: name })
            }
            _ => Err(self.error(self.peek(), "Expect expression.").into()),
        }
    }

    fn is_at_end(&self) -> bool {
        if self.current >= self.tokens.len() {
            true
        } else {
            self.tokens[self.current].token_type == TokenType::Eof
        }
    }

    fn advance(&mut self) -> &Token {
        if !self.is_at_end() {
            self.current += 1;
        }
        self.peek()
    }

    fn peek(&self) -> &Token {
        if self.is_at_end() {
            &self.tokens.last().unwrap()
        } else {
            &self.tokens[self.current]
        }
    }

    fn peek_next(&self) -> &Token {
        if self.is_at_end() {
            &self.peek()
        } else {
            &self.tokens[self.current + 1]
        }
    }

    fn previous(&self) -> &Token {
        &self.tokens[self.current - 1]
    }

    fn consume(&mut self, token_type: TokenType, message: &str) -> LoxResult<&Token> {
        if self.peek().token_type == token_type {
            self.advance();
            Ok(self.previous())
        } else {
            Err(self.error(self.peek(), message).into())
        }
    }

    fn error(&self, token: &Token, message: &str) -> LoxError {
        LoxError::ParseError {
            source_slice: token.source_slice.clone(),
            message: message.to_string(),
        }
    }

    fn synchronize(&mut self) {
        self.advance();

        while !self.is_at_end() {
            if self.previous().token_type == TokenType::Semicolon {
                return;
            }

            match self.peek().token_type {
                TokenType::Class
                | TokenType::Fun
                | TokenType::Var
                | TokenType::For
                | TokenType::If
                | TokenType::While
                | TokenType::Print
                | TokenType::Return => return,
                _ => {}
            }

            self.advance();
        }
    }
}