dust/dust-lang/src/parser.rs

use std::{
    fmt::{self, Display, Formatter},
    mem,
    num::ParseIntError,
};

use crate::{
    Chunk, ChunkError, DustError, Identifier, Instruction, LexError, Lexer, Span, Token, TokenKind,
    TokenOwned, Value,
};

pub fn parse(source: &str) -> Result<Chunk, DustError> {
    let lexer = Lexer::new(source);
    let mut parser = Parser::new(lexer);

    while !parser.is_eof() {
        parser
            .parse_statement()
            .map_err(|error| DustError::Parse { error, source })?;
    }

    Ok(parser.chunk)
}

#[derive(Debug)]
pub struct Parser<'src> {
    lexer: Lexer<'src>,
    chunk: Chunk,
    previous_token: Token<'src>,
    previous_position: Span,
    current_token: Token<'src>,
    current_position: Span,
}

impl<'src> Parser<'src> {
    pub fn new(mut lexer: Lexer<'src>) -> Self {
        let (current_token, current_position) =
            lexer.next_token().unwrap_or((Token::Eof, Span(0, 0)));

        log::trace!("Starting parser with token {current_token} at {current_position}");

        Parser {
            lexer,
            chunk: Chunk::new(),
            previous_token: Token::Eof,
            previous_position: Span(0, 0),
            current_token,
            current_position,
        }
    }

    fn is_eof(&self) -> bool {
        matches!(self.current_token, Token::Eof)
    }

    fn advance(&mut self) -> Result<(), ParseError> {
        let (new_token, position) = self.lexer.next_token()?;

        log::trace!("Advancing to token {new_token} at {position}");

        self.previous_token = mem::replace(&mut self.current_token, new_token);
        self.previous_position = mem::replace(&mut self.current_position, position);

        Ok(())
    }

    fn allow(&mut self, allowed: TokenKind) -> Result<bool, ParseError> {
        if self.current_token.kind() == allowed {
            self.advance()?;

            Ok(true)
        } else {
            Ok(false)
        }
    }

    fn expect(&mut self, expected: TokenKind) -> Result<(), ParseError> {
        if self.current_token.kind() == expected {
            self.advance()
        } else {
            Err(ParseError::ExpectedToken {
                expected,
                found: self.current_token.to_owned(),
                position: self.current_position,
            })
        }
    }

    fn emit_byte(&mut self, byte: u8, position: Span) {
        self.chunk.write(byte, position);
    }

    fn emit_constant(&mut self, value: Value) -> Result<(), ParseError> {
        let constant_index = self.chunk.push_constant(value)?;
        let position = self.previous_position;

        self.emit_byte(Instruction::Constant as u8, position);
        self.emit_byte(constant_index, position);

        Ok(())
    }

    fn parse_boolean(&mut self) -> Result<(), ParseError> {
        if let Token::Boolean(text) = self.previous_token {
            let boolean = text.parse::<bool>().unwrap();
            let value = Value::boolean(boolean);

            self.emit_constant(value)?;
        }

        Ok(())
    }

    fn parse_float(&mut self) -> Result<(), ParseError> {
        if let Token::Float(text) = self.previous_token {
            let float = text.parse::<f64>().unwrap();
            let value = Value::float(float);

            self.emit_constant(value)?;
        }

        Ok(())
    }

    fn parse_integer(&mut self) -> Result<(), ParseError> {
        if let Token::Integer(text) = self.previous_token {
            let integer = text.parse::<i64>().unwrap();
            let value = Value::integer(integer);

            self.emit_constant(value)?;
        }

        Ok(())
    }

    fn parse_string(&mut self) -> Result<(), ParseError> {
        if let Token::String(text) = self.previous_token {
            let value = Value::string(text);

            self.emit_constant(value)?;
        }

        Ok(())
    }

    fn parse_grouped(&mut self) -> Result<(), ParseError> {
        self.parse_expression()?;
        self.expect(TokenKind::RightParenthesis)
    }

    fn parse_unary(&mut self) -> Result<(), ParseError> {
        let operator_position = self.previous_position;
        let byte = match self.previous_token.kind() {
            TokenKind::Minus => Instruction::Negate as u8,
            _ => {
                return Err(ParseError::ExpectedTokenMultiple {
                    expected: vec![TokenKind::Minus],
                    found: self.previous_token.to_owned(),
                    position: operator_position,
                })
            }
        };

        self.parse_expression()?;
        self.emit_byte(byte, operator_position);

        Ok(())
    }

    fn parse_binary(&mut self) -> Result<(), ParseError> {
        let operator_position = self.previous_position;
        let operator = self.previous_token.kind();
        let rule = ParseRule::from(&operator);

        self.parse(rule.precedence.increment())?;

        let byte = match operator {
            TokenKind::Plus => Instruction::Add as u8,
            TokenKind::Minus => Instruction::Subtract as u8,
            TokenKind::Star => Instruction::Multiply as u8,
            TokenKind::Slash => Instruction::Divide as u8,
            _ => {
                return Err(ParseError::ExpectedTokenMultiple {
                    expected: vec![
                        TokenKind::Plus,
                        TokenKind::Minus,
                        TokenKind::Star,
                        TokenKind::Slash,
                    ],
                    found: self.previous_token.to_owned(),
                    position: operator_position,
                })
            }
        };

        self.emit_byte(byte, operator_position);

        Ok(())
    }

    fn parse_variable(&mut self) -> Result<(), ParseError> {
        todo!()
    }

    fn parse_identifier(&mut self) -> Result<u8, ParseError> {
        if let Token::Identifier(text) = self.current_token {
            self.advance()?;

            let identifier = Identifier::new(text);
            let identifier_index = self.chunk.push_identifier(identifier)?;

            Ok(identifier_index)
        } else {
            Err(ParseError::ExpectedToken {
                expected: TokenKind::Identifier,
                found: self.current_token.to_owned(),
                position: self.current_position,
            })
        }
    }

    fn parse_expression(&mut self) -> Result<(), ParseError> {
        self.parse(Precedence::None)
    }

    fn parse_statement(&mut self) -> Result<(), ParseError> {
        match self.current_token {
            Token::Let => self.parse_let_assignment()?,
            _ => self.parse_expression_statement()?,
        }

        Ok(())
    }

    fn parse_expression_statement(&mut self) -> Result<(), ParseError> {
        let start = self.current_position.0;

        self.parse_expression()?;

        if self.allow(TokenKind::Semicolon)? {
            let end = self.previous_position.1;

            self.emit_byte(Instruction::Pop as u8, Span(start, end));
        }

        Ok(())
    }

    fn parse_let_assignment(&mut self) -> Result<(), ParseError> {
        self.expect(TokenKind::Let)?;

        let position = self.current_position;
        let identifier_index = self.parse_identifier()?;

        self.expect(TokenKind::Equal)?;
        self.parse_expression()?;
        self.expect(TokenKind::Semicolon)?;
        self.define_variable(identifier_index, position)
    }

    fn define_variable(&mut self, identifier_index: u8, position: Span) -> Result<(), ParseError> {
        self.emit_byte(Instruction::DefineGlobal as u8, position);
        self.emit_byte(identifier_index, position);

        Ok(())
    }

    fn parse(&mut self, precedence: Precedence) -> Result<(), ParseError> {
        self.advance()?;

        if let Some(prefix) = ParseRule::from(&self.previous_token.kind()).prefix {
            log::trace!(
                "Parsing {} as prefix with precedence {precedence}",
                self.previous_token,
            );

            prefix(self)?;
        } else {
            return Err(ParseError::ExpectedExpression {
                found: self.previous_token.to_owned(),
                position: self.previous_position,
            });
        }

        while precedence < ParseRule::from(&self.current_token.kind()).precedence {
            self.advance()?;

            let infix_rule = ParseRule::from(&self.previous_token.kind()).infix;

            if let Some(infix) = infix_rule {
                log::trace!(
                    "Parsing {} as infix with precedence {precedence}",
                    self.previous_token,
                );

                infix(self)?;
            } else {
                break;
            }
        }

        Ok(())
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Precedence {
    None = 0,
    Assignment = 1,
    Conditional = 2,
    LogicalOr = 3,
    LogicalAnd = 4,
    Equality = 5,
    Comparison = 6,
    Term = 7,
    Factor = 8,
    Unary = 9,
    Call = 10,
    Primary = 11,
}

impl Precedence {
    fn from_byte(byte: u8) -> Self {
        match byte {
            0 => Self::None,
            1 => Self::Assignment,
            2 => Self::Conditional,
            3 => Self::LogicalOr,
            4 => Self::LogicalAnd,
            5 => Self::Equality,
            6 => Self::Comparison,
            7 => Self::Term,
            8 => Self::Factor,
            9 => Self::Unary,
            10 => Self::Call,
            _ => Self::Primary,
        }
    }

    fn increment(&self) -> Self {
        Self::from_byte(*self as u8 + 1)
    }
}

impl Display for Precedence {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

type ParserFunction<'a> = fn(&mut Parser<'a>) -> Result<(), ParseError>;

#[derive(Debug, Clone, Copy)]
pub struct ParseRule<'a> {
    pub prefix: Option<ParserFunction<'a>>,
    pub infix: Option<ParserFunction<'a>>,
    pub precedence: Precedence,
}

impl From<&TokenKind> for ParseRule<'_> {
    fn from(token_kind: &TokenKind) -> Self {
        match token_kind {
            TokenKind::Eof => ParseRule {
                prefix: None,
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::Identifier => ParseRule {
                prefix: Some(Parser::parse_variable),
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::Boolean => ParseRule {
                prefix: Some(Parser::parse_boolean),
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::Character => todo!(),
            TokenKind::Float => ParseRule {
                prefix: Some(Parser::parse_float),
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::Integer => ParseRule {
                prefix: Some(Parser::parse_integer),
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::String => ParseRule {
                prefix: Some(Parser::parse_string),
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::Async => todo!(),
            TokenKind::Bool => todo!(),
            TokenKind::Break => todo!(),
            TokenKind::Else => todo!(),
            TokenKind::FloatKeyword => todo!(),
            TokenKind::If => todo!(),
            TokenKind::Int => todo!(),
            TokenKind::Let => todo!(),
            TokenKind::Loop => todo!(),
            TokenKind::Map => todo!(),
            TokenKind::Str => todo!(),
            TokenKind::While => todo!(),
            TokenKind::BangEqual => todo!(),
            TokenKind::Bang => todo!(),
            TokenKind::Colon => todo!(),
            TokenKind::Comma => todo!(),
            TokenKind::Dot => todo!(),
            TokenKind::DoubleAmpersand => todo!(),
            TokenKind::DoubleDot => todo!(),
            TokenKind::DoubleEqual => todo!(),
            TokenKind::DoublePipe => todo!(),
            TokenKind::Equal => todo!(),
            TokenKind::Greater => todo!(),
            TokenKind::GreaterOrEqual => todo!(),
            TokenKind::LeftCurlyBrace => todo!(),
            TokenKind::LeftParenthesis => ParseRule {
                prefix: Some(Parser::parse_grouped),
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::LeftSquareBrace => todo!(),
            TokenKind::Less => todo!(),
            TokenKind::LessOrEqual => todo!(),
            TokenKind::Minus => ParseRule {
                prefix: Some(Parser::parse_unary),
                infix: Some(Parser::parse_binary),
                precedence: Precedence::Term,
            },
            TokenKind::MinusEqual => todo!(),
            TokenKind::Mut => todo!(),
            TokenKind::Percent => todo!(),
            TokenKind::Plus => ParseRule {
                prefix: None,
                infix: Some(Parser::parse_binary),
                precedence: Precedence::Term,
            },
            TokenKind::PlusEqual => todo!(),
            TokenKind::RightCurlyBrace => todo!(),
            TokenKind::RightParenthesis => ParseRule {
                prefix: None,
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::RightSquareBrace => todo!(),
            TokenKind::Semicolon => ParseRule {
                prefix: None,
                infix: None,
                precedence: Precedence::None,
            },
            TokenKind::Star => ParseRule {
                prefix: None,
                infix: Some(Parser::parse_binary),
                precedence: Precedence::Factor,
            },
            TokenKind::Struct => todo!(),
            TokenKind::Slash => ParseRule {
                prefix: None,
                infix: Some(Parser::parse_binary),
                precedence: Precedence::Factor,
            },
        }
    }
}

#[derive(Debug, PartialEq)]
pub enum ParseError {
    ExpectedExpression {
        found: TokenOwned,
        position: Span,
    },
    ExpectedToken {
        expected: TokenKind,
        found: TokenOwned,
        position: Span,
    },
    ExpectedTokenMultiple {
        expected: Vec<TokenKind>,
        found: TokenOwned,
        position: Span,
    },

    // Wrappers around foreign errors
    Chunk(ChunkError),
    Lex(LexError),
    ParseIntError(ParseIntError),
}

impl From<ParseIntError> for ParseError {
    fn from(error: ParseIntError) -> Self {
        Self::ParseIntError(error)
    }
}

impl From<LexError> for ParseError {
    fn from(error: LexError) -> Self {
        Self::Lex(error)
    }
}

impl From<ChunkError> for ParseError {
    fn from(error: ChunkError) -> Self {
        Self::Chunk(error)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn let_statement() {
        let source = "let x = 42;";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![
                    (Instruction::Constant as u8, Span(8, 10)),
                    (0, Span(8, 10)),
                    (Instruction::DefineGlobal as u8, Span(4, 5)),
                    (0, Span(4, 5))
                ],
                vec![Value::integer(42)],
                vec![Identifier::new("x")]
            ))
        );
    }

    #[test]
    fn string() {
        let source = "\"Hello, World!\"";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![(Instruction::Constant as u8, Span(0, 15)), (0, Span(0, 15))],
                vec![Value::string("Hello, World!")],
                vec![]
            ))
        );
    }

    #[test]
    fn integer() {
        let source = "42";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![(Instruction::Constant as u8, Span(0, 2)), (0, Span(0, 2))],
                vec![Value::integer(42)],
                vec![]
            ))
        );
    }

    #[test]
    fn boolean() {
        let source = "true";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![(Instruction::Constant as u8, Span(0, 4)), (0, Span(0, 4))],
                vec![Value::boolean(true)],
                vec![]
            ))
        );
    }

    #[test]
    fn grouping() {
        let source = "(42 + 42) * 2";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![
                    (Instruction::Constant as u8, Span(1, 3)),
                    (0, Span(1, 3)),
                    (Instruction::Constant as u8, Span(6, 8)),
                    (1, Span(6, 8)),
                    (Instruction::Add as u8, Span(4, 5)),
                    (Instruction::Constant as u8, Span(12, 13)),
                    (2, Span(12, 13)),
                    (Instruction::Multiply as u8, Span(10, 11)),
                ],
                vec![Value::integer(42), Value::integer(42), Value::integer(2)],
                vec![]
            ))
        );
    }

    #[test]
    fn negation() {
        let source = "-(42)";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![
                    (Instruction::Constant as u8, Span(2, 4)),
                    (0, Span(2, 4)),
                    (Instruction::Negate as u8, Span(0, 1)),
                ],
                vec![Value::integer(42)],
                vec![]
            ))
        );
    }

    #[test]
    fn addition() {
        let source = "42 + 42";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![
                    (Instruction::Constant as u8, Span(0, 2)),
                    (0, Span(0, 2)),
                    (Instruction::Constant as u8, Span(5, 7)),
                    (1, Span(5, 7)),
                    (Instruction::Add as u8, Span(3, 4)),
                ],
                vec![Value::integer(42), Value::integer(42)],
                vec![]
            ))
        );
    }

    #[test]
    fn subtraction() {
        let source = "42 - 42";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![
                    (Instruction::Constant as u8, Span(0, 2)),
                    (0, Span(0, 2)),
                    (Instruction::Constant as u8, Span(5, 7)),
                    (1, Span(5, 7)),
                    (Instruction::Subtract as u8, Span(3, 4)),
                ],
                vec![Value::integer(42), Value::integer(42)],
                vec![]
            ))
        );
    }

    #[test]
    fn multiplication() {
        let source = "42 * 42";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![
                    (Instruction::Constant as u8, Span(0, 2)),
                    (0, Span(0, 2)),
                    (Instruction::Constant as u8, Span(5, 7)),
                    (1, Span(5, 7)),
                    (Instruction::Multiply as u8, Span(3, 4)),
                ],
                vec![Value::integer(42), Value::integer(42)],
                vec![]
            ))
        );
    }

    #[test]
    fn division() {
        let source = "42 / 42";
        let test_chunk = parse(source);

        assert_eq!(
            test_chunk,
            Ok(Chunk::with_data(
                vec![
                    (Instruction::Constant as u8, Span(0, 2)),
                    (0, Span(0, 2)),
                    (Instruction::Constant as u8, Span(5, 7)),
                    (1, Span(5, 7)),
                    (Instruction::Divide as u8, Span(3, 4)),
                ],
                vec![Value::integer(42), Value::integer(42)],
                vec![]
            ))
        );
    }
}