442 lines
14 KiB
Rust
442 lines
14 KiB
Rust
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<Item = Spanned<Token>>,
|
|
{
|
|
input: &'a str,
|
|
tokens: Peekable<T>,
|
|
current_span: Span,
|
|
}
|
|
|
|
impl<'a, T> Parser<'a, T>
|
|
where
|
|
T: Iterator<Item = Spanned<Token>>,
|
|
{
|
|
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<Spanned<Token>> {
|
|
let next = self.tokens.next()?;
|
|
self.current_span = *next.span();
|
|
Some(next)
|
|
}
|
|
|
|
fn next_expected(&mut self, expected: Token) -> Result<Spanned<Token>, 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<Spanned<Token>> {
|
|
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<Result<Stmt, ParseError>> {
|
|
let mut stmts = Vec::new();
|
|
while self.peek().is_some() {
|
|
stmts.push(self.parse_stmt());
|
|
}
|
|
stmts
|
|
}
|
|
|
|
fn parse_stmt(&mut self) -> Result<Stmt, ParseError> {
|
|
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<Expr, ParseError> {
|
|
match self.peek() {
|
|
Some(Token::Number) => {
|
|
let token = self.next().unwrap();
|
|
let number = LitNumber {
|
|
value: self
|
|
.slice(*token.span())?
|
|
.parse::<f64>()
|
|
.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<String, ParseError> {
|
|
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);
|
|
}
|
|
}
|