From 8b29a4390096ab22b456d4f28769a7f5dd9a13e3 Mon Sep 17 00:00:00 2001
From: Seymur Bagirov <seymur.baghirov@proton.me>
Date: Mon, 6 Jan 2025 01:43:12 +0400
Subject: [PATCH] refactor(literal): remove the Option wrapper for literal for
Expr Simplifies other aspect of the code. Having the LiteralType be wrapped
in an Option was a mistake (i was super sleepy when i was writing that code
:D)
---
src/ast.rs | 2 +-
src/parser.rs | 15 ++++++++++-----
src/printer.rs | 17 ++++++++---------
3 files changed, 19 insertions(+), 15 deletions(-)
diff --git a/src/ast.rs b/src/ast.rs
index bc994bc..7326ef5 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -18,7 +18,7 @@ pub enum Expr {
expression: Box<Expr>,
},
Literal {
- value: Option<LiteralType>,
+ value: LiteralType,
},
Unary {
op: Token,
diff --git a/src/parser.rs b/src/parser.rs
index 853e5f1..7a016f6 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -99,25 +99,30 @@ impl Parser<'_> {
use LiteralType::*;
use TokenType::*;
- fn create_literal(l_type: Option<LiteralType>) -> Expr {
+ fn create_literal(l_type: LiteralType) -> Expr {
Expr::Literal { value: l_type }
}
if self.match_token(&[False]) {
- return Ok(create_literal(Some(Bool(false))));
+ return Ok(create_literal(Bool(false)));
}
if self.match_token(&[True]) {
- return Ok(create_literal(Some(Bool(true))));
+ return Ok(create_literal(Bool(true)));
}
if self.match_token(&[TokenType::Number, TokenType::String]) {
- return Ok(create_literal(self.previous().literal.clone()));
+ return Ok(create_literal(
+ self.previous()
+ .literal
+ .clone()
+ .expect("The number and string token should have a literal"),
+ ));
}
// i included the enum name bcs of ambiguity of LiteralType and TokenType
if self.match_token(&[TokenType::Nil]) {
- return Ok(create_literal(Some(LiteralType::Nil)));
+ return Ok(create_literal(LiteralType::Nil));
}
if self.match_token(&[LeftParen]) {
diff --git a/src/printer.rs b/src/printer.rs
index 0650b37..d10bb76 100644
--- a/src/printer.rs
+++ b/src/printer.rs
@@ -5,11 +5,10 @@ pub fn pretty_print(expr: &Expr) -> String {
Expr::Binary { left, op, right } => parenthesize(&op.lexeme, &[left, right]),
Expr::Grouping { expression } => parenthesize("group", &[expression]),
Expr::Literal { value } => match value {
- Some(LiteralType::String(v)) => v.to_string(),
- Some(LiteralType::Number(v)) => v.to_string(),
- Some(LiteralType::Bool(v)) => v.to_string(),
- Some(LiteralType::Nil) => "Nil".to_string(),
- None => "None".to_string(),
+ LiteralType::String(v) => v.to_string(),
+ LiteralType::Number(v) => v.to_string(),
+ LiteralType::Bool(v) => v.to_string(),
+ LiteralType::Nil => "Nil".to_string(),
},
Expr::Unary { op, right } => parenthesize(&op.lexeme, &[right]),
Expr::Ternary {
@@ -50,7 +49,7 @@ mod test {
use TokenType::*;
let expression = Binary {
left: Box::new(Literal {
- value: Some(LiteralType::Number(10.2)),
+ value: LiteralType::Number(10.2),
}),
op: Token {
t_type: Plus,
@@ -59,7 +58,7 @@ mod test {
line: 0,
},
right: Box::new(Literal {
- value: Some(LiteralType::Number(10.2)),
+ value: LiteralType::Number(10.2),
}),
};
@@ -77,13 +76,13 @@ mod test {
left: Box::new(Unary {
op: Token::new(Minus, "-", None, 0),
right: Box::new(Expr::Literal {
- value: Some(LiteralType::number_literal(123.0)),
+ value: LiteralType::number_literal(123.0),
}),
}),
op: Token::new(Star, "*", None, 0),
right: Box::new(Grouping {
expression: Box::new(Literal {
- value: Some(LiteralType::number_literal(45.67)),
+ value: LiteralType::number_literal(45.67),
}),
}),
};