Added variable expr.

This commit is contained in:
2026-11-15 10:46:57 +01:00
parent c2e306321d
commit 06168ae704
+77 -18
View File
@@ -27,16 +27,16 @@ where
} }
} }
fn peek_token(&mut self) -> Option<&Token> { fn peek(&mut self) -> Option<&Token> {
self.tokens.peek().map(|spanned| spanned.node()) self.tokens.peek().map(|spanned| spanned.node())
} }
fn next_token(&mut self) -> Option<Spanned<Token>> { fn next(&mut self) -> Option<Spanned<Token>> {
self.tokens.next() self.tokens.next()
} }
fn expect(&mut self, expected: Token) -> Result<Spanned<Token>, ParseError> { fn next_expected(&mut self, expected: Token) -> Result<Spanned<Token>, ParseError> {
let next = self.next_token().ok_or_else(|| ParseError { let next = self.next().ok_or_else(|| ParseError {
span: self.current_span, span: self.current_span,
message: format!("Expected {:?}, found end of file", expected), message: format!("Expected {:?}, found end of file", expected),
})?; })?;
@@ -62,25 +62,25 @@ where
pub fn parse(&mut self) -> Vec<Result<Stmt, ParseError>> { pub fn parse(&mut self) -> Vec<Result<Stmt, ParseError>> {
let mut stmts = Vec::new(); let mut stmts = Vec::new();
while self.peek_token().is_some() { while self.peek().is_some() {
stmts.push(self.parse_stmt()); stmts.push(self.parse_stmt());
} }
stmts stmts
} }
fn parse_stmt(&mut self) -> Result<Stmt, ParseError> { fn parse_stmt(&mut self) -> Result<Stmt, ParseError> {
match self.peek_token() { match self.peek() {
Some(Token::Let) => { Some(Token::Let) => {
let r#let = self.next_token().unwrap(); let r#let = self.next().unwrap();
let ident = self.expect(Token::Ident).map(|spanned| { let ident = self.next_expected(Token::Ident).map(|spanned| {
Ok(Ident { Ok(Ident {
name: self.slice(*spanned.span())?.to_string(), name: self.slice(*spanned.span())?.to_string(),
span: *spanned.span(), span: *spanned.span(),
}) })
})??; })??;
self.expect(Token::Equals)?; self.next_expected(Token::Equals)?;
let expr = self.parse_expr()?; let expr = self.parse_expr()?;
let semi = self.expect(Token::Semicolon)?; let semi = self.next_expected(Token::Semicolon)?;
Ok(Let { Ok(Let {
name: ident, name: ident,
ty: None, ty: None,
@@ -107,9 +107,9 @@ where
} }
fn parse_expr(&mut self) -> Result<Expr, ParseError> { fn parse_expr(&mut self) -> Result<Expr, ParseError> {
match self.peek_token() { match self.peek() {
Some(Token::Number) => { Some(Token::Number) => {
let token = self.next_token().unwrap(); let token = self.next().unwrap();
let raw = self.slice(*token.span())?; let raw = self.slice(*token.span())?;
let number = LitNumber { let number = LitNumber {
value: raw.parse::<f64>().map_err(|e| ParseError { value: raw.parse::<f64>().map_err(|e| ParseError {
@@ -121,7 +121,7 @@ where
Ok(Expr::Literal(number.into())) Ok(Expr::Literal(number.into()))
} }
Some(Token::String) => { Some(Token::String) => {
let token = self.next_token().unwrap(); let token = self.next().unwrap();
let raw = self.slice(*token.span())?; let raw = self.slice(*token.span())?;
let string = LitString { let string = LitString {
value: raw[1..raw.len() - 1].to_string(), value: raw[1..raw.len() - 1].to_string(),
@@ -130,9 +130,10 @@ where
Ok(Expr::Literal(string.into())) Ok(Expr::Literal(string.into()))
} }
Some(Token::Ident) => { Some(Token::Ident) => {
let token = self.next_token().unwrap(); let token = self.next().unwrap();
let raw = self.slice(*token.span())?;
let ident = Ident { let ident = Ident {
name: self.slice(*token.span())?.to_string(), name: raw.to_string(),
span: *token.span(), span: *token.span(),
}; };
Ok(Expr::Variable(ident)) Ok(Expr::Variable(ident))
@@ -194,7 +195,50 @@ mod tests {
span: Span::new(0, 14), span: Span::new(0, 14),
})) }))
); );
pretty_assertions::assert_eq!(parser.next_token(), None); 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] #[test]
@@ -212,7 +256,7 @@ mod tests {
.into() .into()
)) ))
); );
pretty_assertions::assert_eq!(parser.next_token(), None); pretty_assertions::assert_eq!(parser.next(), None);
} }
#[test] #[test]
@@ -230,6 +274,21 @@ mod tests {
.into() .into()
)) ))
); );
pretty_assertions::assert_eq!(parser.next_token(), None); pretty_assertions::assert_eq!(parser.next(), None);
}
#[test]
fn expr_variable() {
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);
} }
} }