From 0fd19a623d0ee36606ce79ec9b8deed0394c55b9 Mon Sep 17 00:00:00 2001 From: Jeff Date: Sat, 17 Aug 2024 12:15:47 -0400 Subject: [PATCH] Improve AST ergonomics --- dust-lang/src/ast/expression.rs | 186 ++++++++++-- dust-lang/src/parser.rs | 502 ++++++++++++-------------------- dust-lang/src/token.rs | 4 + dust-lang/src/vm.rs | 15 +- 4 files changed, 352 insertions(+), 355 deletions(-) diff --git a/dust-lang/src/ast/expression.rs b/dust-lang/src/ast/expression.rs index bf41b3e..22e4b08 100644 --- a/dust-lang/src/ast/expression.rs +++ b/dust-lang/src/ast/expression.rs @@ -32,10 +32,10 @@ pub enum Expression { } impl Expression { - pub fn map(pairs: Vec<(Node, Expression)>, position: Span) -> Self { + pub fn map, Expression)>>>(pairs: T, position: Span) -> Self { Self::Map(Node::new( Box::new(MapExpression { - pairs: pairs.into_iter().collect(), + pairs: pairs.into(), }), position, )) @@ -214,24 +214,40 @@ impl Expression { Self::Struct(Node::new(Box::new(struct_expression), position)) } - pub fn identifier(identifier: Identifier, position: Span) -> Self { - Self::Identifier(Node::new(identifier, position)) + pub fn identifier(to_string: T, position: Span) -> Self { + Self::Identifier(Node::new(Identifier::new(to_string), position)) } - pub fn list(list_expression: ListExpression, position: Span) -> Self { - Self::List(Node::new(Box::new(list_expression), position)) + pub fn list>>(expressions: T, position: Span) -> Self { + Self::List(Node::new( + Box::new(ListExpression::Ordered(expressions.into())), + position, + )) } - pub fn list_index(list_index: ListIndexExpression, position: Span) -> Self { - Self::ListIndex(Node::new(Box::new(list_index), position)) + pub fn auto_fill_list(repeat: Expression, length: Expression, position: Span) -> Self { + Self::List(Node::new( + Box::new(ListExpression::AutoFill { + repeat_operand: repeat, + length_operand: length, + }), + position, + )) + } + + pub fn list_index(list: Expression, index: Expression, position: Span) -> Self { + Self::ListIndex(Node::new( + Box::new(ListIndexExpression { list, index }), + position, + )) } pub fn r#if(r#if: IfExpression, position: Span) -> Self { Self::If(Node::new(Box::new(r#if), position)) } - pub fn literal(literal: LiteralExpression, position: Span) -> Self { - Self::Literal(Node::new(Box::new(literal), position)) + pub fn literal>(into_literal: T, position: Span) -> Self { + Self::Literal(Node::new(Box::new(into_literal.into()), position)) } pub fn has_block(&self) -> bool { @@ -325,9 +341,12 @@ impl Expression { } } Expression::Literal(literal_expression) => match literal_expression.inner.as_ref() { - LiteralExpression::Boolean(_) => Some(Type::Boolean), - LiteralExpression::Float(_) => Some(Type::Float), - LiteralExpression::Integer(_) => Some(Type::Integer), + LiteralExpression::Primitive(primitive_value) => match primitive_value { + PrimitiveValueExpression::Boolean(_) => Some(Type::Boolean), + PrimitiveValueExpression::Character(_) => Some(Type::Character), + PrimitiveValueExpression::Integer(_) => Some(Type::Integer), + PrimitiveValueExpression::Float(_) => Some(Type::Float), + }, LiteralExpression::String(_) => Some(Type::String), }, Expression::Loop(loop_expression) => match loop_expression.inner.as_ref() { @@ -361,7 +380,7 @@ impl Expression { Expression::Range(range_expression) => { let start = match range_expression.inner.as_ref() { RangeExpression::Exclusive { start, .. } => start, - RangeExpression::Inclusive { start, end } => start, + RangeExpression::Inclusive { start, .. } => start, }; let start_type = start.return_type(context)?; let rangeable_type = match start_type { @@ -578,20 +597,114 @@ impl Display for ListExpression { } #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub enum LiteralExpression { +pub enum PrimitiveValueExpression { Boolean(bool), + Character(char), Float(f64), Integer(i64), - String(String), +} + +impl Display for PrimitiveValueExpression { + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + match self { + PrimitiveValueExpression::Boolean(boolean) => write!(f, "{boolean}"), + PrimitiveValueExpression::Character(character) => write!(f, "{character}"), + PrimitiveValueExpression::Float(float) => write!(f, "{float}"), + PrimitiveValueExpression::Integer(integer) => write!(f, "{integer}"), + } + } +} + +impl Eq for PrimitiveValueExpression {} + +impl PartialOrd for PrimitiveValueExpression { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for PrimitiveValueExpression { + fn cmp(&self, other: &Self) -> Ordering { + match (self, other) { + (PrimitiveValueExpression::Boolean(left), PrimitiveValueExpression::Boolean(right)) => { + left.cmp(right) + } + (PrimitiveValueExpression::Boolean(_), _) => Ordering::Greater, + ( + PrimitiveValueExpression::Character(left), + PrimitiveValueExpression::Character(right), + ) => left.cmp(right), + (PrimitiveValueExpression::Character(_), _) => Ordering::Greater, + (PrimitiveValueExpression::Float(left), PrimitiveValueExpression::Float(right)) => { + left.to_bits().cmp(&right.to_bits()) + } + (PrimitiveValueExpression::Float(_), _) => Ordering::Greater, + (PrimitiveValueExpression::Integer(left), PrimitiveValueExpression::Integer(right)) => { + left.cmp(right) + } + (PrimitiveValueExpression::Integer(_), _) => Ordering::Greater, + } + } +} + +#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] +pub struct RawStringExpression(pub String); + +impl Display for RawStringExpression { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +impl From for LiteralExpression { + fn from(value: i64) -> Self { + LiteralExpression::Primitive(PrimitiveValueExpression::Integer(value)) + } +} + +impl From for LiteralExpression { + fn from(value: String) -> Self { + LiteralExpression::String(RawStringExpression(value)) + } +} + +impl From<&str> for LiteralExpression { + fn from(value: &str) -> Self { + LiteralExpression::String(RawStringExpression(value.to_string())) + } +} + +impl From for LiteralExpression { + fn from(value: f64) -> Self { + LiteralExpression::Primitive(PrimitiveValueExpression::Float(value)) + } +} + +impl From for LiteralExpression { + fn from(value: bool) -> Self { + LiteralExpression::Primitive(PrimitiveValueExpression::Boolean(value)) + } +} + +impl From for LiteralExpression { + fn from(value: char) -> Self { + LiteralExpression::Primitive(PrimitiveValueExpression::Character(value)) + } +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub enum LiteralExpression { + Primitive(PrimitiveValueExpression), + String(RawStringExpression), } impl Display for LiteralExpression { fn fmt(&self, f: &mut Formatter) -> fmt::Result { match self { - LiteralExpression::Boolean(boolean) => write!(f, "{}", boolean), - LiteralExpression::Float(float) => write!(f, "{}", float), - LiteralExpression::Integer(integer) => write!(f, "{}", integer), - LiteralExpression::String(string) => write!(f, "{}", string), + LiteralExpression::Primitive(primitive) => { + write!(f, "{primitive}") + } + LiteralExpression::String(string) => write!(f, "{string}"), } } } @@ -607,17 +720,12 @@ impl PartialOrd for LiteralExpression { impl Ord for LiteralExpression { fn cmp(&self, other: &Self) -> Ordering { match (self, other) { - (LiteralExpression::Boolean(left), LiteralExpression::Boolean(right)) => { - left.cmp(right) - } - (LiteralExpression::Float(left), LiteralExpression::Float(right)) => { - left.to_bits().cmp(&right.to_bits()) - } - (LiteralExpression::Integer(left), LiteralExpression::Integer(right)) => { + (LiteralExpression::Primitive(left), LiteralExpression::Primitive(right)) => { left.cmp(right) } + (LiteralExpression::Primitive(_), _) => Ordering::Greater, (LiteralExpression::String(left), LiteralExpression::String(right)) => left.cmp(right), - _ => unreachable!(), + (LiteralExpression::String(_), _) => Ordering::Greater, } } } @@ -726,6 +834,28 @@ pub enum MathOperator { Modulo, } +impl MathOperator { + pub fn add(position: Span) -> Node { + Node::new(MathOperator::Add, position) + } + + pub fn subtract(position: Span) -> Node { + Node::new(MathOperator::Subtract, position) + } + + pub fn multiply(position: Span) -> Node { + Node::new(MathOperator::Multiply, position) + } + + pub fn divide(position: Span) -> Node { + Node::new(MathOperator::Divide, position) + } + + pub fn modulo(position: Span) -> Node { + Node::new(MathOperator::Modulo, position) + } +} + impl Display for MathOperator { fn fmt(&self, f: &mut Formatter) -> fmt::Result { let operator = match self { diff --git a/dust-lang/src/parser.rs b/dust-lang/src/parser.rs index 9359ef5..4bab951 100644 --- a/dust-lang/src/parser.rs +++ b/dust-lang/src/parser.rs @@ -418,27 +418,23 @@ impl<'src> Parser<'src> { Token::Boolean(text) => { self.next_token()?; - let boolean = text.parse().map_err(|error| ParseError::Boolean { + let boolean = text.parse::().map_err(|error| ParseError::Boolean { error, position: start_position, })?; - let statement = - Expression::literal(LiteralExpression::Boolean(boolean), start_position); + let statement = Expression::literal(boolean, start_position); Ok(statement) } Token::Float(text) => { self.next_token()?; - let float = text.parse().map_err(|error| ParseError::Float { + let float = text.parse::().map_err(|error| ParseError::Float { error, position: start_position, })?; - Ok(Expression::literal( - LiteralExpression::Float(float), - start_position, - )) + Ok(Expression::literal(float, start_position)) } Token::Identifier(text) => { self.next_token()?; @@ -502,10 +498,7 @@ impl<'src> Parser<'src> { position: start_position, })?; - Ok(Expression::literal( - LiteralExpression::Integer(integer), - start_position, - )) + Ok(Expression::literal(integer, start_position)) } Token::If => { self.next_token()?; @@ -518,10 +511,7 @@ impl<'src> Parser<'src> { Token::String(text) => { self.next_token()?; - Ok(Expression::literal( - LiteralExpression::String(text.to_string()), - start_position, - )) + Ok(Expression::literal(text.to_string(), start_position)) } Token::LeftCurlyBrace => { let block_node = self.parse_block()?; @@ -555,10 +545,7 @@ impl<'src> Parser<'src> { self.next_token()?; - return Ok(Expression::list( - ListExpression::Ordered(Vec::new()), - position, - )); + return Ok(Expression::list(Vec::new(), position)); } let first_expression = self.parse_expression(0)?; @@ -573,11 +560,9 @@ impl<'src> Parser<'src> { self.next_token()?; - return Ok(Expression::list( - ListExpression::AutoFill { - length_operand: first_expression, - repeat_operand, - }, + return Ok(Expression::auto_fill_list( + first_expression, + repeat_operand, position, )); } else { @@ -597,10 +582,7 @@ impl<'src> Parser<'src> { self.next_token()?; - return Ok(Expression::list( - ListExpression::Ordered(expressions), - position, - )); + return Ok(Expression::list(expressions, position)); } if let Token::Comma = self.current_token { @@ -899,7 +881,7 @@ impl<'src> Parser<'src> { let position = (left.position().0, operator_end); - Expression::list_index(ListIndexExpression { list: left, index }, position) + Expression::list_index(left, index, position) } _ => { return Err(ParseError::ExpectedTokenMultiple { @@ -1184,18 +1166,15 @@ mod tests { vec![ ( Node::new(Identifier::new("x"), (6, 7)), - Expression::literal( - LiteralExpression::String("1".to_string()), - (10, 13) - ), + Expression::literal("1".to_string(), (10, 13)), ), ( Node::new(Identifier::new("y"), (15, 16)), - Expression::literal(LiteralExpression::Integer(2), (19, 20)), + Expression::literal(2, (19, 20)), ), ( Node::new(Identifier::new("z"), (22, 23)), - Expression::literal(LiteralExpression::Float(3.0), (26, 29)), + Expression::literal(3.0, (26, 29)), ), ], (0, 31), @@ -1216,7 +1195,7 @@ mod tests { Statement::Let(Node::new( LetStatement::LetMut { identifier: Node::new(Identifier::new("x"), (8, 9)), - value: Expression::literal(LiteralExpression::Integer(0), (12, 13)), + value: Expression::literal(0, (12, 13)), }, (0, 14), )), @@ -1225,7 +1204,7 @@ mod tests { Expression::comparison( Expression::identifier(Identifier::new("x"), (21, 22)), Node::new(ComparisonOperator::LessThan, (23, 24)), - Expression::literal(LiteralExpression::Integer(10), (25, 27)), + Expression::literal(10, (25, 27)), (21, 27), ), Node::new( @@ -1233,10 +1212,7 @@ mod tests { Expression::compound_assignment( Expression::identifier(Identifier::new("x"), (30, 31)), Node::new(MathOperator::Add, (32, 34)), - Expression::literal( - LiteralExpression::Integer(1), - (35, 36) - ), + Expression::literal(1, (35, 36)), (30, 36), ), )]), @@ -1263,7 +1239,7 @@ mod tests { statements: [Statement::Let(Node::new( LetStatement::Let { identifier: Node::new(Identifier::new("x"), (4, 5)), - value: Expression::literal(LiteralExpression::Integer(42), (8, 10)), + value: Expression::literal(42, (8, 10)), }, (0, 11), ))] @@ -1282,7 +1258,7 @@ mod tests { statements: [Statement::Let(Node::new( LetStatement::LetMut { identifier: Node::new(Identifier::new("x"), (8, 9)), - value: Expression::literal(LiteralExpression::Boolean(false), (12, 17)), + value: Expression::literal(false, (12, 17)), }, (0, 18), ))] @@ -1308,10 +1284,7 @@ mod tests { Identifier::new("x"), (8, 9) ), - value: Expression::literal( - LiteralExpression::Integer(42), - (12, 14) - ), + value: Expression::literal(42, (12, 14)), }, (8, 14) ), @@ -1323,10 +1296,7 @@ mod tests { Identifier::new("y"), (16, 17) ), - value: Expression::literal( - LiteralExpression::Float(4.0), - (20, 23) - ), + value: Expression::literal(4.0, (20, 23)), }, (16, 23) )) @@ -1351,11 +1321,8 @@ mod tests { Expression::call( Expression::identifier(Identifier::new("Foo"), (0, 3)), vec![ - Expression::literal(LiteralExpression::Integer(42), (4, 6)), - Expression::literal( - LiteralExpression::String("bar".to_string()), - (8, 13) - ), + Expression::literal(42, (4, 6)), + Expression::literal("bar".to_string(), (8, 13)), ], (0, 15) ), @@ -1369,11 +1336,6 @@ mod tests { #[test] fn fields_struct_instantiation() { let source = "Foo { a: 42, b: 4.0 }"; - let mut tree = AbstractSyntaxTree::new(); - - if parse_into(source, &mut tree).is_err() { - println!("{:?}", tree); - } assert_eq!( parse(source), @@ -1384,11 +1346,11 @@ mod tests { fields: vec![ ( Node::new(Identifier::new("a"), (6, 7)), - Expression::literal(LiteralExpression::Integer(42), (9, 11)), + Expression::literal(42, (9, 11)), ), ( Node::new(Identifier::new("b"), (13, 14)), - Expression::literal(LiteralExpression::Float(4.0), (16, 19)) + Expression::literal(4.0, (16, 19)) ) ] }, @@ -1435,8 +1397,8 @@ mod tests { Statement::Expression(Expression::call( Expression::identifier(Identifier::new("Foo"), (0, 3)), vec![ - Expression::literal(LiteralExpression::Integer(1), (4, 5)), - Expression::literal(LiteralExpression::Float(2.0), (7, 10)) + Expression::literal(1, (4, 5)), + Expression::literal(2.0, (7, 10)) ], (0, 11) )) @@ -1490,31 +1452,21 @@ mod tests { parse(source), Ok(AbstractSyntaxTree::with_statements([ Statement::Expression(Expression::list_index( - ListIndexExpression { - list: Expression::list_index( - ListIndexExpression { - list: Expression::list( - ListExpression::Ordered(vec![ - Expression::literal(LiteralExpression::Integer(1), (1, 2)), - Expression::list( - ListExpression::Ordered(vec![Expression::literal( - LiteralExpression::Integer(2), - (5, 6) - )]), - (4, 7) - ), - Expression::literal(LiteralExpression::Integer(3), (9, 10)), - ]), - (0, 11) - ), - index: Expression::literal(LiteralExpression::Integer(1), (12, 13)), - }, - (0, 14) + Expression::list_index( + Expression::list( + [ + Expression::literal(1, (1, 2)), + Expression::list([Expression::literal(2, (5, 6))], (4, 7)), + Expression::literal(3, (9, 10)), + ], + (0, 11) ), - index: Expression::literal(LiteralExpression::Integer(0), (15, 16)), - }, + Expression::literal(1, (12, 13)), + (0, 14) + ), + Expression::literal(0, (15, 16)), (0, 17) - )) + ),) ])) ); } @@ -1527,8 +1479,8 @@ mod tests { parse(source), Ok(AbstractSyntaxTree::with_statements([ Statement::Expression(Expression::exclusive_range( - Expression::literal(LiteralExpression::Integer(0), (0, 1)), - Expression::literal(LiteralExpression::Integer(42), (3, 5)), + Expression::literal(0, (0, 1)), + Expression::literal(42, (3, 5)), (0, 5) )) ])) @@ -1546,7 +1498,7 @@ mod tests { Expression::operator( OperatorExpression::Assignment { assignee: Expression::identifier(Identifier::new("a"), (0, 1)), - value: Expression::literal(LiteralExpression::Integer(1), (4, 5)), + value: Expression::literal(1, (4, 5)), }, (0, 5) ), @@ -1574,9 +1526,9 @@ mod tests { OperatorExpression::Negation(Expression::grouped( Expression::operator( OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(1), (2, 3)), + left: Expression::literal(1, (2, 3)), operator: Node::new(MathOperator::Add, (4, 5)), - right: Expression::literal(LiteralExpression::Integer(1), (6, 7)), + right: Expression::literal(1, (6, 7)), }, (2, 7) ), @@ -1599,9 +1551,9 @@ mod tests { OperatorExpression::Not(Expression::grouped( Expression::operator( OperatorExpression::Comparison { - left: Expression::literal(LiteralExpression::Integer(1), (2, 3)), + left: Expression::literal(1, (2, 3)), operator: Node::new(ComparisonOperator::GreaterThan, (4, 5)), - right: Expression::literal(LiteralExpression::Integer(42), (6, 8)), + right: Expression::literal(42, (6, 8)), }, (2, 8) ), @@ -1624,7 +1576,7 @@ mod tests { Expression::operator( OperatorExpression::Assignment { assignee: Expression::identifier(Identifier::new("a"), (0, 1)), - value: Expression::literal(LiteralExpression::Boolean(false), (4, 9)), + value: Expression::literal(false, (4, 9)), }, (0, 9) ), @@ -1756,10 +1708,7 @@ mod tests { OperatorExpression::Comparison { left: Expression::identifier(Identifier::new("x"), (6, 7)), operator: Node::new(ComparisonOperator::LessThan, (8, 9)), - right: Expression::literal( - LiteralExpression::Integer(10), - (10, 12) - ), + right: Expression::literal(10, (10, 12)), }, (6, 12) ), @@ -1772,10 +1721,7 @@ mod tests { (15, 16) ), operator: Node::new(MathOperator::Add, (17, 19)), - modifier: Expression::literal( - LiteralExpression::Integer(1), - (20, 21) - ), + modifier: Expression::literal(1, (20, 21)), }, (15, 21) ) @@ -1801,7 +1747,7 @@ mod tests { OperatorExpression::CompoundAssignment { assignee: Expression::identifier(Identifier::new("a"), (0, 1)), operator: Node::new(MathOperator::Add, (2, 4)), - modifier: Expression::literal(LiteralExpression::Integer(1), (5, 6)), + modifier: Expression::literal(1, (5, 6)), }, (0, 6) )) @@ -1818,9 +1764,9 @@ mod tests { Ok(AbstractSyntaxTree::with_statements([ Statement::Expression(Expression::operator( OperatorExpression::Logic { - left: Expression::literal(LiteralExpression::Boolean(true), (0, 4)), + left: Expression::literal(true, (0, 4)), operator: Node::new(LogicOperator::Or, (5, 7)), - right: Expression::literal(LiteralExpression::Boolean(false), (8, 13)), + right: Expression::literal(false, (8, 13)), }, (0, 13) )) @@ -1839,9 +1785,9 @@ mod tests { Expression::block( BlockExpression::Sync(vec![Statement::Expression(Expression::operator( OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(40), (2, 4)), + left: Expression::literal(40, (2, 4)), operator: Node::new(MathOperator::Add, (5, 6)), - right: Expression::literal(LiteralExpression::Integer(2), (7, 8)), + right: Expression::literal(2, (7, 8)), }, (2, 8) ))]), @@ -1864,50 +1810,26 @@ mod tests { Expression::block( BlockExpression::Sync(vec![ Statement::ExpressionNullified(Node::new( - Expression::operator( - OperatorExpression::Assignment { - assignee: Expression::identifier( - Identifier::new("foo"), - (2, 5) - ), - value: Expression::literal( - LiteralExpression::Integer(42), - (8, 10) - ), - }, + Expression::assignment( + Expression::identifier("foo", (2, 5)), + Expression::literal(42, (8, 10)), (2, 10) ), (2, 11) - ),), + )), Statement::ExpressionNullified(Node::new( - Expression::operator( - OperatorExpression::Assignment { - assignee: Expression::identifier( - Identifier::new("bar"), - (12, 15) - ), - value: Expression::literal( - LiteralExpression::Integer(42), - (18, 20) - ), - }, + Expression::assignment( + Expression::identifier("bar", (12, 15)), + Expression::literal(42, (18, 20)), (12, 20) ), (12, 21) - ),), - Statement::Expression(Expression::operator( - OperatorExpression::Assignment { - assignee: Expression::identifier( - Identifier::new("baz"), - (22, 25) - ), - value: Expression::literal( - LiteralExpression::String("42".to_string()), - (28, 32) - ), - }, - (22, 32) )), + Statement::Expression(Expression::assignment( + Expression::identifier("baz", (22, 25)), + Expression::literal("42", (28, 32)), + (22, 32) + )) ]), (0, 34) ), @@ -1924,13 +1846,11 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Comparison { - left: Expression::literal(LiteralExpression::Integer(42), (0, 2)), - operator: Node::new(ComparisonOperator::Equal, (3, 5)), - right: Expression::literal(LiteralExpression::Integer(42), (6, 8)), - }, - (0, 8), + Statement::Expression(Expression::comparison( + Expression::literal(42, (0, 2)), + Node::new(ComparisonOperator::Equal, (3, 5)), + Expression::literal(42, (6, 8)), + (0, 8) )) ])) ); @@ -1943,13 +1863,11 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Comparison { - left: Expression::literal(LiteralExpression::Integer(1), (0, 1)), - operator: Node::new(ComparisonOperator::LessThan, (2, 3)), - right: Expression::literal(LiteralExpression::Integer(2), (4, 5)), - }, - (0, 5), + Statement::Expression(Expression::comparison( + Expression::literal(1, (0, 1)), + Node::new(ComparisonOperator::LessThan, (2, 3)), + Expression::literal(2, (4, 5)), + (0, 5) )) ])) ); @@ -1962,13 +1880,11 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Comparison { - left: Expression::literal(LiteralExpression::Integer(1), (0, 1)), - operator: Node::new(ComparisonOperator::LessThanOrEqual, (2, 4)), - right: Expression::literal(LiteralExpression::Integer(2), (5, 6)), - }, - (0, 6), + Statement::Expression(Expression::comparison( + Expression::literal(1, (0, 1)), + Node::new(ComparisonOperator::LessThanOrEqual, (2, 4)), + Expression::literal(2, (5, 6)), + (0, 6) )) ])) ); @@ -1981,13 +1897,11 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Comparison { - left: Expression::literal(LiteralExpression::Integer(1), (0, 1)), - operator: Node::new(ComparisonOperator::GreaterThanOrEqual, (2, 4)), - right: Expression::literal(LiteralExpression::Integer(2), (5, 6)), - }, - (0, 6), + Statement::Expression(Expression::comparison( + Expression::literal(1, (0, 1)), + Node::new(ComparisonOperator::GreaterThanOrEqual, (2, 4)), + Expression::literal(2, (5, 6)), + (0, 6) )) ])) ); @@ -2000,13 +1914,11 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Comparison { - left: Expression::literal(LiteralExpression::Integer(1), (0, 1)), - operator: Node::new(ComparisonOperator::GreaterThan, (2, 3)), - right: Expression::literal(LiteralExpression::Integer(2), (4, 5)), - }, - (0, 5), + Statement::Expression(Expression::comparison( + Expression::literal(1, (0, 1)), + Node::new(ComparisonOperator::GreaterThan, (2, 3)), + Expression::literal(2, (4, 5)), + (0, 5) )) ])) ); @@ -2019,13 +1931,11 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(-1), (0, 2)), - operator: Node::new(MathOperator::Subtract, (3, 4)), - right: Expression::literal(LiteralExpression::Integer(-2), (5, 7)), - }, - (0, 7), + Statement::Expression(Expression::math( + Expression::literal(-1, (0, 2)), + MathOperator::subtract((3, 4)), + Expression::literal(-2, (5, 7)), + (0, 7) )) ])) ); @@ -2038,13 +1948,11 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(42), (0, 2)), - operator: Node::new(MathOperator::Modulo, (3, 4)), - right: Expression::literal(LiteralExpression::Integer(2), (5, 6)), - }, - (0, 6), + Statement::Expression(Expression::math( + Expression::literal(42, (0, 2)), + MathOperator::modulo((3, 4)), + Expression::literal(2, (5, 6)), + (0, 6) )) ])) ); @@ -2057,13 +1965,11 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(42), (0, 2)), - operator: Node::new(MathOperator::Divide, (3, 4)), - right: Expression::literal(LiteralExpression::Integer(2), (5, 6)), - }, - (0, 6), + Statement::Expression(Expression::math( + Expression::literal(42, (0, 2)), + MathOperator::divide((3, 4)), + Expression::literal(2, (5, 6)), + (0, 6) )) ])) ); @@ -2076,18 +1982,10 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Math { - left: Expression::literal( - LiteralExpression::String("Hello, ".to_string()), - (0, 9) - ), - operator: Node::new(MathOperator::Add, (10, 11)), - right: Expression::literal( - LiteralExpression::String("World!".to_string()), - (12, 20) - ) - }, + Statement::Expression(Expression::math( + Expression::literal("Hello, ", (0, 9)), + MathOperator::add((10, 11)), + Expression::literal("World!", (12, 20)), (0, 20) )) ])) @@ -2101,10 +1999,7 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::literal( - LiteralExpression::String("Hello, World!".to_string()), - (0, 15) - )) + Statement::Expression(Expression::literal("Hello, World!", (0, 15))) ])) ); } @@ -2116,10 +2011,7 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::literal( - LiteralExpression::Boolean(true), - (0, 4) - )) + Statement::Expression(Expression::literal(true, (0, 4))) ])) ); } @@ -2132,17 +2024,15 @@ mod tests { parse(source), Ok(AbstractSyntaxTree::with_statements([ Statement::Expression(Expression::list_index( - ListIndexExpression { - list: Expression::list( - ListExpression::Ordered(vec![ - Expression::literal(LiteralExpression::Integer(1), (1, 2)), - Expression::literal(LiteralExpression::Integer(2), (4, 5)), - Expression::literal(LiteralExpression::Integer(3), (7, 8)), - ]), - (0, 9) - ), - index: Expression::literal(LiteralExpression::Integer(0), (10, 11)), - }, + Expression::list( + [ + Expression::literal(1, (1, 2)), + Expression::literal(2, (4, 5)), + Expression::literal(3, (7, 8)), + ], + (0, 9) + ), + Expression::literal(0, (10, 11)), (0, 12) )) ])) @@ -2173,41 +2063,29 @@ mod tests { parse(source), Ok(AbstractSyntaxTree::with_statements([ Statement::Expression(Expression::list( - ListExpression::Ordered(vec![ - Expression::literal(LiteralExpression::Integer(1), (1, 2)), - Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(1), (4, 5)), - operator: Node::new(MathOperator::Add, (6, 7)), - right: Expression::literal(LiteralExpression::Integer(1), (8, 9)), - }, + [ + Expression::literal(1, (1, 2)), + Expression::math( + Expression::literal(1, (4, 5)), + MathOperator::add((6, 7)), + Expression::literal(1, (8, 9)), (4, 9) ), - Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(2), (11, 12)), - operator: Node::new(MathOperator::Add, (13, 14)), - right: Expression::grouped( - Expression::operator( - OperatorExpression::Math { - left: Expression::literal( - LiteralExpression::Integer(4), - (16, 17) - ), - operator: Node::new(MathOperator::Multiply, (18, 19)), - right: Expression::literal( - LiteralExpression::Integer(10), - (20, 22) - ), - }, - (16, 22) - ), - (15, 23) + Expression::math( + Expression::literal(2, (11, 12)), + Node::new(MathOperator::Add, (13, 14)), + Expression::grouped( + Expression::math( + Expression::literal(4, (16, 17)), + MathOperator::multiply((18, 19)), + Expression::literal(10, (20, 22)), + (16, 22) ), - }, + (15, 23) + ), (11, 23) - ) - ]), + ), + ], (0, 24) )) ])) @@ -2222,10 +2100,10 @@ mod tests { parse(source), Ok(AbstractSyntaxTree::with_statements([ Statement::Expression(Expression::list( - ListExpression::Ordered(vec![ - Expression::literal(LiteralExpression::Integer(1), (1, 2)), - Expression::literal(LiteralExpression::Integer(2), (4, 5)) - ]), + [ + Expression::literal(1, (1, 2)), + Expression::literal(2, (4, 5)) + ], (0, 6) )) ])) @@ -2239,7 +2117,7 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::list(ListExpression::Ordered(vec![]), (0, 2))) + Statement::Expression(Expression::list(vec![], (0, 2))) ])) ); } @@ -2251,7 +2129,7 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::literal(LiteralExpression::Float(42.0), (0, 4))) + Statement::Expression(Expression::literal(42.0, (0, 4))) ])) ); } @@ -2263,12 +2141,10 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(1), (0, 1)), - operator: Node::new(MathOperator::Add, (2, 3)), - right: Expression::literal(LiteralExpression::Integer(2), (4, 5)) - }, + Statement::Expression(Expression::math( + Expression::literal(1, (0, 1)), + MathOperator::add((2, 3)), + Expression::literal(2, (4, 5)), (0, 5) )) ])) @@ -2282,14 +2158,12 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(1), (0, 1)), - operator: Node::new(MathOperator::Multiply, (2, 3)), - right: Expression::literal(LiteralExpression::Integer(2), (4, 5)) - }, + Statement::Expression(Expression::math( + Expression::literal(1, (0, 1)), + MathOperator::multiply((2, 3)), + Expression::literal(2, (4, 5)), (0, 5) - )) + ),) ])) ); } @@ -2301,21 +2175,17 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(1), (0, 1)), - operator: Node::new(MathOperator::Add, (2, 3)), - right: Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(2), (4, 5)), - operator: Node::new(MathOperator::Multiply, (6, 7)), - right: Expression::literal(LiteralExpression::Integer(3), (8, 9)) - }, - (4, 9) - ) - }, + Statement::Expression(Expression::math( + Expression::literal(1, (0, 1)), + MathOperator::add((2, 3)), + Expression::math( + Expression::literal(2, (4, 5)), + MathOperator::multiply((6, 7)), + Expression::literal(3, (8, 9)), + (4, 9) + ), (0, 9) - )) + )), ])) ); } @@ -2327,31 +2197,19 @@ mod tests { assert_eq!( parse(source), Ok(AbstractSyntaxTree::with_statements([ - Statement::Expression(Expression::operator( - OperatorExpression::Assignment { - assignee: Expression::identifier(Identifier::new("a"), (0, 1)), - value: Expression::operator( - OperatorExpression::Math { - left: Expression::literal(LiteralExpression::Integer(1), (4, 5)), - operator: Node::new(MathOperator::Add, (6, 7)), - right: Expression::operator( - OperatorExpression::Math { - left: Expression::literal( - LiteralExpression::Integer(2), - (8, 9) - ), - operator: Node::new(MathOperator::Multiply, (10, 11)), - right: Expression::literal( - LiteralExpression::Integer(3), - (12, 13) - ) - }, - (8, 13) - ) - }, - (4, 13) - ) - }, + Statement::Expression(Expression::assignment( + Expression::identifier("a", (0, 1)), + Expression::math( + Expression::literal(1, (4, 5)), + MathOperator::add((6, 7)), + Expression::math( + Expression::literal(2, (8, 9)), + MathOperator::multiply((10, 11)), + Expression::literal(3, (12, 13)), + (8, 13) + ), + (4, 13) + ), (0, 13) )) ])) diff --git a/dust-lang/src/token.rs b/dust-lang/src/token.rs index 060ce57..ca96e63 100644 --- a/dust-lang/src/token.rs +++ b/dust-lang/src/token.rs @@ -3,6 +3,10 @@ use std::fmt::{self, Display, Formatter}; use serde::{Deserialize, Serialize}; +pub struct Raw<'src> { + data: &'src str, +} + /// Source code token. #[derive(Debug, Serialize, Deserialize, PartialEq)] pub enum Token<'src> { diff --git a/dust-lang/src/vm.rs b/dust-lang/src/vm.rs index d69e3aa..ec12eb8 100644 --- a/dust-lang/src/vm.rs +++ b/dust-lang/src/vm.rs @@ -7,6 +7,7 @@ use std::{ collections::HashMap, fmt::{self, Display, Formatter}, + primitive, sync::{Arc, Mutex}, }; @@ -17,7 +18,8 @@ use crate::{ AbstractSyntaxTree, BlockExpression, CallExpression, ComparisonOperator, ElseExpression, FieldAccessExpression, IfExpression, LetStatement, ListExpression, ListIndexExpression, LiteralExpression, LogicOperator, LoopExpression, MapExpression, MathOperator, Node, - OperatorExpression, RangeExpression, Span, Statement, StructDefinition, StructExpression, + OperatorExpression, PrimitiveValueExpression, RangeExpression, RawStringExpression, Span, + Statement, StructDefinition, StructExpression, }, parse, Analyzer, BuiltInFunctionError, Context, DustError, Expression, FieldsStructType, Identifier, ParseError, Struct, StructType, TupleType, Type, Value, ValueError, @@ -617,10 +619,13 @@ impl Vm { fn run_literal(&self, literal: LiteralExpression) -> Result { let value = match literal { - LiteralExpression::Boolean(boolean) => Value::Boolean(boolean), - LiteralExpression::Float(float) => Value::Float(float), - LiteralExpression::Integer(integer) => Value::Integer(integer), - LiteralExpression::String(string) => Value::String(string), + LiteralExpression::String(RawStringExpression(string)) => Value::String(string), + LiteralExpression::Primitive(primitive_expression) => match primitive_expression { + PrimitiveValueExpression::Boolean(boolean) => Value::Boolean(boolean), + PrimitiveValueExpression::Character(character) => Value::Character(character), + PrimitiveValueExpression::Integer(integer) => Value::Integer(integer), + PrimitiveValueExpression::Float(float) => Value::Float(float), + }, }; Ok(Evaluation::Return(Some(value)))