use std::iter::Peekable; use crate::{ ast::{Expr, FnCall, Ident, Let, LitNumber, LitString, Stmt}, lexer::Token, span::{Span, Spanned}, }; pub struct Parser<'a, T> where T: Iterator>, { input: &'a str, tokens: Peekable, current_span: Span, } impl<'a, T> Parser<'a, T> where T: Iterator>, { pub fn new(input: &'a str, tokens: T) -> Self { Self { input, tokens: tokens.peekable(), current_span: Span::default(), } } fn peek(&mut self) -> Option<&Token> { self.tokens.peek().map(|spanned| spanned.node()) } fn next(&mut self) -> Option> { let next = self.tokens.next()?; self.current_span = *next.span(); Some(next) } fn next_expected(&mut self, expected: Token) -> Result, ParseError> { let next = self.next().ok_or_else(|| ParseError { span: self.current_span, message: format!("Expected {:?}, found end of file", expected), })?; if next.node() == &expected { Ok(next) } else { Err(ParseError { span: self.current_span, message: format!("Expected {:?}, found {:?}", expected, next.node()), }) } } fn next_if(&mut self, expected: Token) -> Option> { if self.peek() == Some(&expected) { self.next() } else { None } } fn slice(&self, span: Span) -> Result<&'a str, ParseError> { self.input .get(span.start()..span.end()) .ok_or_else(|| ParseError { span, message: "Span out of bounds".to_string(), }) } pub fn parse(&mut self) -> Vec> { let mut stmts = Vec::new(); while self.peek().is_some() { stmts.push(self.parse_stmt()); } stmts } fn parse_stmt(&mut self) -> Result { match self.peek() { Some(Token::Let) => { let r#let = self.next().unwrap(); let ident = self.next_expected(Token::Ident)?; let ident = Ident { name: self.slice(*ident.span())?.to_string(), span: *ident.span(), }; self.next_expected(Token::Equals)?; let expr = self.parse_expr()?; let semi = self.next_expected(Token::Semicolon)?; Ok(Let { name: ident, ty: None, value: expr, span: r#let.span_to(&semi), } .into()) } Some(Token::Ident) => { unimplemented!() } Some(Token::Fn) => { unimplemented!() } Some(_) => Err(ParseError { span: self.current_span, message: "Unexpected token in statement".to_string(), }), None => Err(ParseError { span: self.current_span, message: "Unexpected end of file".to_string(), }), } } fn parse_expr(&mut self) -> Result { match self.peek() { Some(Token::Number) => { let token = self.next().unwrap(); let number = LitNumber { value: self .slice(*token.span())? .parse::() .map_err(|e| ParseError { span: *token.span(), message: format!("Failed to parse number: {}", e), })?, span: *token.span(), }; Ok(Expr::Literal(number.into())) } Some(Token::String) => { let token = self.next().unwrap(); let raw = self.slice(*token.span())?; let unquoted = Self::unquote_string(raw, token.span().start())?; let escaped = Self::unescape_string(unquoted, token.span().start() + 1)?; let string = LitString { value: escaped, span: *token.span(), }; Ok(Expr::Literal(string.into())) } Some(Token::Ident) => { let token = self.next().unwrap(); let ident = Ident { name: self.slice(*token.span())?.to_string(), span: *token.span(), }; match self.peek() { Some(Token::ParenL) => { self.next().unwrap(); let mut args = Vec::new(); while self.peek() != Some(&Token::ParenR) { args.push(self.parse_expr()?); if self.next_if(Token::Comma).is_none() { break; } } let rparen = self.next_expected(Token::ParenR)?; let fncall = FnCall { name: ident, args, span: token.span_to(&rparen), }; Ok(Expr::FnCall(fncall)) } _ => Ok(Expr::Variable(ident)), } } Some(_) => Err(ParseError { span: self.current_span, message: "Unexpected token in expression".to_string(), }), None => Err(ParseError { span: self.current_span, message: "Unexpected end of file".to_string(), }), } } fn unquote_string<'s>(s: &'s str, offset: usize) -> Result<&'s str, ParseError> { Ok(s.strip_prefix('"') .and_then(|s| s.strip_suffix('"')) .ok_or_else(|| ParseError { span: Span::new(offset, offset + s.len()), message: "Malformed string literal: missing quotes".to_string(), })?) } fn unescape_string(s: &str, offset: usize) -> Result { let mut result = String::new(); let mut chars = s.char_indices(); while let Some((_, c)) = chars.next() { if c == '\\' { match chars.next() { Some((_, 'n')) => result.push('\n'), Some((_, 't')) => result.push('\t'), Some((_, 'r')) => result.push('\r'), Some((_, '"')) => result.push('"'), Some((_, '\\')) => result.push('\\'), Some((i, other)) => { let start = offset + i; return Err(ParseError { span: Span::new(start, start + other.len_utf8()), message: format!("Unknown escape sequence: \\{}", other), }); } None => { let start = offset + s.len(); return Err(ParseError { span: Span::new(start, start), message: "Incomplete escape sequence".to_string(), }); } } } else { result.push(c); } } Ok(result) } } #[derive(Debug, PartialEq)] pub struct ParseError { span: Span, message: String, } impl ParseError { pub fn span(&self) -> Span { self.span } pub fn message(&self) -> &str { &self.message } } #[cfg(test)] mod tests { use crate::lexer::Lexer; use super::*; #[test] fn stmt_lets() { let input = "let x = 500.0;"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_stmt(), Ok(Stmt::Let(Let { name: Ident { name: "x".to_string(), span: Span::new(4, 5), }, ty: None, value: Expr::Literal( LitNumber { value: 500.0, span: Span::new(8, 13) } .into() ), span: Span::new(0, 14), })) ); pretty_assertions::assert_eq!(parser.next(), None); let input = "let x = \"hello\";"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_stmt(), Ok(Stmt::Let(Let { name: Ident { name: "x".to_string(), span: Span::new(4, 5), }, ty: None, value: Expr::Literal( LitString { value: "hello".to_string(), span: Span::new(8, 15) } .into() ), span: Span::new(0, 16), })) ); pretty_assertions::assert_eq!(parser.next(), None); let input = "let x = y;"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_stmt(), Ok(Stmt::Let(Let { name: Ident { name: "x".to_string(), span: Span::new(4, 5), }, ty: None, value: Expr::Variable(Ident { name: "y".to_string(), span: Span::new(8, 9), }), span: Span::new(0, 10), })) ); pretty_assertions::assert_eq!(parser.next(), None); } #[test] fn expr_numbers() { let input = "500.0"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_expr(), Ok(Expr::Literal( LitNumber { value: 500.0, span: Span::new(0, 5) } .into() )) ); pretty_assertions::assert_eq!(parser.next(), None); } #[test] fn expr_strings() { let input = "\"hello\\n\\t\\\\hey\""; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_expr(), Ok(Expr::Literal( LitString { value: "hello\n\t\\hey".to_string(), span: Span::new(0, 16) } .into() )) ); pretty_assertions::assert_eq!(parser.next(), None); } #[test] fn expr_string_errors() { let input = "\"hello"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_expr(), Err(ParseError { span: Span::new(0, 6), message: "Malformed string literal: missing quotes".to_string() }) ); pretty_assertions::assert_eq!(parser.next(), None); let input = "\"hello \\\""; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_expr(), Err(ParseError { span: Span::new(8, 8), message: "Incomplete escape sequence".to_string() }) ); pretty_assertions::assert_eq!(parser.next(), None); } #[test] fn expr_variables() { let input = "x"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_expr(), Ok(Expr::Variable(Ident { name: "x".to_string(), span: Span::new(0, 1) })) ); pretty_assertions::assert_eq!(parser.next(), None); } #[test] fn expr_fncalls() { let input = "f(x)"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_expr(), Ok(Expr::FnCall(FnCall { name: Ident { name: "f".to_string(), span: Span::new(0, 1), }, args: vec![Expr::Variable(Ident { name: "x".to_string(), span: Span::new(2, 3), })], span: Span::new(0, 4), })) ); pretty_assertions::assert_eq!(parser.next(), None); let input = "f(x, y)"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); pretty_assertions::assert_eq!( parser.parse_expr(), Ok(Expr::FnCall(FnCall { name: Ident { name: "f".to_string(), span: Span::new(0, 1), }, args: vec![ Expr::Variable(Ident { name: "x".to_string(), span: Span::new(2, 3), }), Expr::Variable(Ident { name: "y".to_string(), span: Span::new(5, 6), }), ], span: Span::new(0, 7), })) ); pretty_assertions::assert_eq!(parser.next(), None); } }