diff --git a/Cargo.lock b/Cargo.lock index a96b264..1c45635 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,31 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "diff" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" + +[[package]] +name = "pretty_assertions" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d" +dependencies = [ + "diff", + "yansi", +] + [[package]] name = "rscript" version = "0.1.0" +dependencies = [ + "pretty_assertions", +] + +[[package]] +name = "yansi" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" diff --git a/Cargo.toml b/Cargo.toml index c73794b..df50ad6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,3 +4,6 @@ version = "0.1.0" edition = "2024" [dependencies] + +[dev-dependencies] +pretty_assertions = "1.4.1" diff --git a/src/ast.rs b/src/ast.rs index b91f5ac..e307a30 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -1,7 +1,6 @@ -pub struct Script { - pub items: Vec, -} +use crate::span::Span; +#[derive(Debug, PartialEq)] pub enum Stmt { Let(Let), Assign(Assign), @@ -9,56 +8,119 @@ pub enum Stmt { Fn(FnDef), } +impl From for Stmt { + fn from(let_stmt: Let) -> Self { + Stmt::Let(let_stmt) + } +} + +impl From for Stmt { + fn from(assign_stmt: Assign) -> Self { + Stmt::Assign(assign_stmt) + } +} + +impl From for Stmt { + fn from(expr_stmt: Expr) -> Self { + Stmt::Expr(expr_stmt) + } +} + +impl From for Stmt { + fn from(fn_def: FnDef) -> Self { + Stmt::Fn(fn_def) + } +} + +#[derive(Debug, PartialEq)] pub struct Let { pub name: Ident, pub ty: Option, pub value: Expr, + pub span: Span, } +#[derive(Debug, PartialEq)] pub struct Assign { pub name: Ident, pub value: Expr, } +#[derive(Debug, PartialEq)] pub struct FnDef { pub name: Ident, pub params: Vec, pub body: Vec, } +#[derive(Debug, PartialEq)] pub struct FnParam { pub name: Ident, pub ty: Type, } +#[derive(Debug, PartialEq)] pub enum Expr { Literal(Literal), Variable(Ident), FnCall(FnCall), } +impl From for Expr { + fn from(lit: LitNumber) -> Self { + Expr::Literal(lit.into()) + } +} + +impl From for Expr { + fn from(lit: LitString) -> Self { + Expr::Literal(lit.into()) + } +} + +#[derive(Debug, PartialEq)] pub enum Literal { Number(LitNumber), String(LitString), } +impl From for Literal { + fn from(lit: LitNumber) -> Self { + Literal::Number(lit) + } +} + +impl From for Literal { + fn from(lit: LitString) -> Self { + Literal::String(lit) + } +} + +#[derive(Debug, PartialEq)] pub struct LitNumber { pub value: f64, + pub span: Span, } +#[derive(Debug, PartialEq)] pub struct LitString { pub value: String, + pub span: Span, } +#[derive(Debug, PartialEq)] pub struct FnCall { pub name: Ident, pub args: Vec, } +#[derive(Debug, PartialEq)] pub struct Ident { pub name: String, + pub span: Span, } +#[derive(Debug, PartialEq)] pub enum Type { Number, String, diff --git a/src/lib.rs b/src/lib.rs index 49b11ef..ab6892c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,5 @@ pub mod ast; pub mod cursor; pub mod lexer; +pub mod parser; pub mod span; diff --git a/src/parser.rs b/src/parser.rs index 8b13789..09fb30c 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -1 +1,218 @@ +use std::iter::Peekable; +use crate::{ + ast::{Expr, Ident, Let, LitNumber, 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_token(&mut self) -> Option<&Token> { + self.tokens.peek().map(|spanned| spanned.node()) + } + + fn next_token(&mut self) -> Option> { + self.tokens.next() + } + + fn expect(&mut self, expected: Token) -> Result, ParseError> { + let next = self.next_token().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 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_token().is_some() { + stmts.push(self.parse_stmt()); + } + stmts + } + + fn parse_stmt(&mut self) -> Result { + match self.peek_token() { + Some(Token::Let) => { + let r#let = self.next_token().unwrap(); + let ident = self.expect(Token::Ident).map(|spanned| { + Ok(Ident { + name: self.slice(*spanned.span())?.to_string(), + span: *spanned.span(), + }) + })??; + + self.expect(Token::Equals)?; + let expr = self.parse_expr()?; + let semi = self.expect(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_token() { + Some(Token::Number) => { + let number = self.next_token().unwrap(); + Ok(LitNumber { + value: self + .slice(*number.span())? + .parse::() + .map_err(|e| ParseError { + span: *number.span(), + message: format!("Failed to parse number: {}", e), + })?, + span: *number.span(), + } + .into()) + } + 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(), + }), + } + } +} + +#[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 parse_stmt_let_untyped() { + let input = "let x = 500.0;"; + let lexer = Lexer::new(input); + let mut parser = Parser::new(input, lexer); + let result = parser.parse_stmt(); + pretty_assertions::assert_eq!( + result, + Ok(Stmt::Let(Let { + name: Ident { + name: "x".to_string(), + span: Span::new(4, 5), + }, + ty: None, + value: LitNumber { + value: 500.0, + span: Span::new(8, 13) + } + .into(), + span: Span::new(0, 14), + })) + ); + pretty_assertions::assert_eq!(parser.next_token(), None); + } + + #[test] + fn parse_expr_number() { + let input = "500.0"; + let lexer = Lexer::new(input); + let mut parser = Parser::new(input, lexer); + let result = parser.parse_expr(); + pretty_assertions::assert_eq!( + result, + Ok(LitNumber { + value: 500.0, + span: Span::new(0, 5) + } + .into()) + ); + pretty_assertions::assert_eq!(parser.next_token(), None); + } + + #[test] + fn parse_expr_invalid_number() { + let input = "500.0."; + let lexer = Lexer::new(input); + let mut parser = Parser::new(input, lexer); + let result = parser.parse_expr(); + pretty_assertions::assert_eq!( + result, + Err(ParseError { + span: Span::new(0, 6), + message: "Failed to parse number: invalid float literal".to_string() + }) + ); + pretty_assertions::assert_eq!(parser.next_token(), None); + } +} diff --git a/src/span.rs b/src/span.rs index 2e67035..023cc92 100644 --- a/src/span.rs +++ b/src/span.rs @@ -1,4 +1,4 @@ -#[derive(Debug, PartialEq, Eq)] +#[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct Span { start: usize, end: usize, @@ -22,6 +22,12 @@ impl Span { } } +impl Default for Span { + fn default() -> Self { + Span { start: 0, end: 0 } + } +} + #[derive(Debug, PartialEq, Eq)] pub struct Spanned { node: T, @@ -40,4 +46,8 @@ impl Spanned { pub fn span(&self) -> &Span { &self.span } + + pub fn span_to(&self, other: &Spanned) -> Span { + Span::new(self.span.start(), other.span.end()) + } }