jeff/dust
1
0
Fork 0
Code Issues

Improve AST ergonomics

Browse Source
This commit is contained in:
Jeff 2024-08-17 12:15:47 -04:00
parent 0b64afccb1
commit 0fd19a623d
4 changed files with 352 additions and 355 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
dust-lang/src/ast/expression.rs
View File

@ -32,10 +32,10 @@ pub enum Expression {
}
impl Expression {
pub fn map(pairs: Vec<(Node<Identifier>, Expression)>, position: Span) -> Self {
pub fn map<T: Into<Vec<(Node<Identifier>, 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<T: ToString>(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<T: Into<Vec<Expression>>>(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<T: Into<LiteralExpression>>(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<Ordering> {
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<i64> for LiteralExpression {
fn from(value: i64) -> Self {
LiteralExpression::Primitive(PrimitiveValueExpression::Integer(value))
}
}
impl From<String> 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<f64> for LiteralExpression {
fn from(value: f64) -> Self {
LiteralExpression::Primitive(PrimitiveValueExpression::Float(value))
}
}
impl From<bool> for LiteralExpression {
fn from(value: bool) -> Self {
LiteralExpression::Primitive(PrimitiveValueExpression::Boolean(value))
}
}
impl From<char> 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<Self> {
Node::new(MathOperator::Add, position)
}
pub fn subtract(position: Span) -> Node<Self> {
Node::new(MathOperator::Subtract, position)
}
pub fn multiply(position: Span) -> Node<Self> {
Node::new(MathOperator::Multiply, position)
}
pub fn divide(position: Span) -> Node<Self> {
Node::new(MathOperator::Divide, position)
}
pub fn modulo(position: Span) -> Node<Self> {
Node::new(MathOperator::Modulo, position)
}
}
impl Display for MathOperator {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
let operator = match self {

476
dust-lang/src/parser.rs
View File

@ -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::<bool>().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::<f64>().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,
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_index(
Expression::list(
ListExpression::Ordered(vec![Expression::literal(
LiteralExpression::Integer(2),
(5, 6)
)]),
(4, 7)
),
Expression::literal(LiteralExpression::Integer(3), (9, 10)),
]),
[
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(1), (12, 13)),
},
Expression::literal(1, (12, 13)),
(0, 14)
),
index: Expression::literal(LiteralExpression::Integer(0), (15, 16)),
},
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)),
]),
Expression::list(
[
Expression::literal(1, (1, 2)),
Expression::literal(2, (4, 5)),
Expression::literal(3, (7, 8)),
],
(0, 9)
),
index: Expression::literal(LiteralExpression::Integer(0), (10, 11)),
},
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)
),
},
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))
},
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)
)
},
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)
))
]))

4
dust-lang/src/token.rs
View File

@ -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> {

15
dust-lang/src/vm.rs
View File

@ -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<Evaluation, RuntimeError> {
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)))