zaphar/ucg
1
0
Fork 0
mirror of https://github.com/zaphar/ucg.git synced 2025-07-25 18:49:50 -04:00
Code Issues Packages Projects Releases Wiki Activity

Refactored Binary Expressions to a common type and cleaned it up

Browse Source
This commit is contained in:
Jeremy Wall 2017-09-21 00:06:43 -05:00
parent a8b6e7f851
commit f95ecddea2
3 changed files with 259 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/ast.rs
View File

@ -169,25 +169,10 @@ impl MacroDef {
stack.push(expr); stack.push(expr);
while stack.len() > 0 { while stack.len() > 0 {
match stack.pop().unwrap() { match stack.pop().unwrap() {
&Expression::Add(ref bexpr) => { &Expression::Binary(ref bexpr) => {
let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.0); let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.left);
bad_symbols.extend(syms_set.drain()); bad_symbols.extend(syms_set.drain());
stack.push(&bexpr.1); stack.push(&bexpr.right);
},
&Expression::Sub(ref bexpr) => {
let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.0);
bad_symbols.extend(syms_set.drain());
stack.push(&bexpr.1);
},
&Expression::Mul(ref bexpr) => {
let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.0);
bad_symbols.extend(syms_set.drain());
stack.push(&bexpr.1);
},
&Expression::Div(ref bexpr) => {
let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.0);
bad_symbols.extend(syms_set.drain());
stack.push(&bexpr.1);
}, },
&Expression::Grouped(ref expr) => { &Expression::Grouped(ref expr) => {
stack.push(expr); stack.push(expr);
@ -234,9 +219,21 @@ impl MacroDef {
} }
} }
#[derive(Debug,PartialEq,Clone)]
pub enum BinaryExprType {
Add,
Sub,
Mul,
Div,
}
/// BinaryExpression represents an expression with a left and a right side. /// BinaryExpression represents an expression with a left and a right side.
#[derive(Debug,PartialEq,Clone)] #[derive(Debug,PartialEq,Clone)]
pub struct BinaryExpression(pub Value, pub Box<Expression>); pub struct BinaryExpression {
pub kind: BinaryExprType,
pub left: Value,
pub right: Box<Expression>
}
#[derive(Debug,PartialEq,Clone)] #[derive(Debug,PartialEq,Clone)]
pub struct CopyDef { pub struct CopyDef {
@ -256,12 +253,7 @@ pub enum Expression {
// Base Expression // Base Expression
Simple(Value), Simple(Value),
// TODO(jwall): This should probably be all one type :-p Binary(BinaryExpression),
// Binary Expressions
Add(BinaryExpression),
Sub(BinaryExpression),
Mul(BinaryExpression),
Div(BinaryExpression),
// Complex Expressions // Complex Expressions
Copy(CopyDef), Copy(CopyDef),
@ -305,9 +297,10 @@ mod ast_test {
"foo".to_string() "foo".to_string()
], ],
fields: vec![ fields: vec![
("f1".to_string(), Expression::Add(BinaryExpression( ("f1".to_string(), Expression::Binary(BinaryExpression{
Value::Symbol(make_value_node("foo".to_string())), kind: BinaryExprType::Add,
Box::new(Expression::Simple(Value::Int(make_value_node(1))))))), left: Value::Symbol(make_value_node("foo".to_string())),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1))))})),
], ],
}; };
assert!(def.validate_symbols().unwrap() == ()); assert!(def.validate_symbols().unwrap() == ());
@ -320,9 +313,10 @@ mod ast_test {
"foo".to_string() "foo".to_string()
], ],
fields: vec![ fields: vec![
("f1".to_string(), Expression::Add(BinaryExpression( ("f1".to_string(), Expression::Binary(BinaryExpression{
Value::Symbol(make_value_node("bar".to_string())), kind: BinaryExprType::Add,
Box::new(Expression::Simple(Value::Int(make_value_node(1))))))), left: Value::Symbol(make_value_node("bar".to_string())),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1))))})),
], ],
}; };
@ -338,9 +332,10 @@ mod ast_test {
"foo".to_string() "foo".to_string()
], ],
fields: vec![ fields: vec![
("f1".to_string(), Expression::Add(BinaryExpression( ("f1".to_string(), Expression::Binary(BinaryExpression{
Value::Selector(make_value_node(vec!["foo".to_string(), "quux".to_string()])), kind: BinaryExprType::Add,
Box::new(Expression::Simple(Value::Int(make_value_node(1))))))), left: Value::Selector(make_value_node(vec!["foo".to_string(), "quux".to_string()])),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1))))})),
], ],
}; };
assert!(def.validate_symbols().unwrap() == ()); assert!(def.validate_symbols().unwrap() == ());
@ -353,9 +348,10 @@ mod ast_test {
"foo".to_string() "foo".to_string()
], ],
fields: vec![ fields: vec![
("f1".to_string(), Expression::Add(BinaryExpression( ("f1".to_string(), Expression::Binary(BinaryExpression{
Value::Selector(make_value_node(vec!["bar".to_string(), "quux".to_string()])), kind: BinaryExprType::Add,
Box::new(Expression::Simple(Value::Int(make_value_node(1))))))), left: Value::Selector(make_value_node(vec!["bar".to_string(), "quux".to_string()])),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1))))})),
], ],
}; };
let mut expected = HashSet::new(); let mut expected = HashSet::new();

256
src/build.rs
View File

@ -407,93 +407,91 @@ impl Builder {
Expression::Simple(val) => { Expression::Simple(val) => {
self.value_to_val(val) self.value_to_val(val)
}, },
Expression::Add(BinaryExpression(v, expr)) => { Expression::Binary(BinaryExpression{kind, left: v, right: expr}) => {
let expr_result = try!(self.eval_expr(*expr)); let expr_result = try!(self.eval_expr(*expr));
let v = try!(self.value_to_val(v)); let v = try!(self.value_to_val(v));
match *v { match kind {
Val::Int(i) => { BinaryExprType::Add => {
eval_binary_expr!(&Val::Int(ii), expr_result, match *v {
Val::Int(i + ii), "Integer") Val::Int(i) => {
}, eval_binary_expr!(&Val::Int(ii), expr_result,
Val::Float(f) => { Val::Int(i + ii), "Integer")
eval_binary_expr!(&Val::Float(ff), expr_result,
Val::Float(f + ff), "Float")
},
Val::String(ref s) => {
match expr_result.as_ref() {
&Val::String(ref ss) => {
return Ok(Rc::new(
Val::String([s.to_string(), ss.clone()].concat())))
}, },
val => { Val::Float(f) => {
eval_binary_expr!(&Val::Float(ff), expr_result,
Val::Float(f + ff), "Float")
},
Val::String(ref s) => {
match expr_result.as_ref() {
&Val::String(ref ss) => {
return Ok(Rc::new(
Val::String([s.to_string(), ss.clone()].concat())))
},
val => {
return Err(Box::new(
BuildError::TypeFail(
format!("Expected String but got {:?}", val))))
}
}
},
ref expr => {
return Err(Box::new( return Err(Box::new(
BuildError::TypeFail( BuildError::Unsupported(
format!("Expected String but got {:?}", val)))) format!("{} does not support the '+' operation", expr.type_name()))))
} }
} }
}, },
ref expr => { BinaryExprType::Sub => {
return Err(Box::new( match *v {
BuildError::Unsupported( Val::Int(i) => {
format!("{} does not support the '+' operation", expr.type_name())))) eval_binary_expr!(&Val::Int(ii), expr_result,
} Val::Int(i - ii), "Integer")
} },
}, Val::Float(f) => {
Expression::Sub(BinaryExpression(v, expr)) => { eval_binary_expr!(&Val::Float(ff), expr_result,
let expr_result = try!(self.eval_expr(*expr)); Val::Float(f - ff), "Float")
let v = try!(self.value_to_val(v)); },
match *v { ref expr => {
Val::Int(i) => { return Err(Box::new(
eval_binary_expr!(&Val::Int(ii), expr_result, BuildError::Unsupported(
Val::Int(i - ii), "Integer") format!("{} does not support the '-' operation", expr.type_name()))))
}
}
}, },
Val::Float(f) => { BinaryExprType::Mul => {
eval_binary_expr!(&Val::Float(ff), expr_result, match *v {
Val::Float(f - ff), "Float") Val::Int(i) => {
eval_binary_expr!(&Val::Int(ii), expr_result,
Val::Int(i * ii), "Integer")
},
Val::Float(f) => {
eval_binary_expr!(&Val::Float(ff), expr_result,
Val::Float(f * ff), "Float")
},
ref expr => {
return Err(Box::new(
BuildError::Unsupported(
format!("{} does not support the '*' operation", expr.type_name()))))
}
}
}, },
ref expr => { BinaryExprType::Div => {
return Err(Box::new( match *v {
BuildError::Unsupported( Val::Int(i) => {
format!("{} does not support the '-' operation", expr.type_name())))) eval_binary_expr!(&Val::Int(ii), expr_result,
} Val::Int(i / ii), "Integer")
} },
}, Val::Float(f) => {
Expression::Mul(BinaryExpression(v, expr)) => { eval_binary_expr!(&Val::Float(ff), expr_result,
let expr_result = try!(self.eval_expr(*expr)); Val::Float(f / ff), "Float")
let v = try!(self.value_to_val(v)); },
match *v { ref expr => {
Val::Int(i) => { return Err(Box::new(
eval_binary_expr!(&Val::Int(ii), expr_result, BuildError::Unsupported(
Val::Int(i * ii), "Integer") format!("{} does not support the '*' operation", expr.type_name()))))
}
}
}, },
Val::Float(f) => {
eval_binary_expr!(&Val::Float(ff), expr_result,
Val::Float(f * ff), "Float")
},
ref expr => {
return Err(Box::new(
BuildError::Unsupported(
format!("{} does not support the '*' operation", expr.type_name()))))
}
}
},
Expression::Div(BinaryExpression(v, expr)) => {
let expr_result = try!(self.eval_expr(*expr));
let v = try!(self.value_to_val(v));
match *v {
Val::Int(i) => {
eval_binary_expr!(&Val::Int(ii), expr_result,
Val::Int(i / ii), "Integer")
},
Val::Float(f) => {
eval_binary_expr!(&Val::Float(ff), expr_result,
Val::Float(f / ff), "Float")
},
ref expr => {
return Err(Box::new(
BuildError::Unsupported(
format!("{} does not support the '*' operation", expr.type_name()))))
}
} }
}, },
Expression::Copy(mut def) => { Expression::Copy(mut def) => {
@ -622,11 +620,19 @@ mod test {
fn test_eval_div_expr() { fn test_eval_div_expr() {
let b = Builder::new(); let b = Builder::new();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Div(BinaryExpression(Value::Int(make_value_node(2)), (Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))), BinaryExpression{
kind: BinaryExprType::Div,
left: Value::Int(make_value_node(2)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(2)))),
}),
Val::Int(1)), Val::Int(1)),
(Expression::Div(BinaryExpression(Value::Float(make_value_node(2.0)), (Expression::Binary(
Box::new(Expression::Simple(Value::Float(make_value_node(2.0)))))), BinaryExpression{
kind: BinaryExprType::Div,
left: Value::Float(make_value_node(2.0)),
right: Box::new(Expression::Simple(Value::Float(make_value_node(2.0)))),
}),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -636,8 +642,12 @@ mod test {
fn test_eval_div_expr_fail() { fn test_eval_div_expr_fail() {
let b = Builder::new(); let b = Builder::new();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Div(BinaryExpression(Value::Float(make_value_node(2.0)), (Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))), BinaryExpression{
kind: BinaryExprType::Div,
left: Value::Float(make_value_node(2.0)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(2))))
}),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -646,11 +656,19 @@ mod test {
fn test_eval_mul_expr() { fn test_eval_mul_expr() {
let b = Builder::new(); let b = Builder::new();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Mul(BinaryExpression(Value::Int(make_value_node(2)), (Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))), BinaryExpression{
kind: BinaryExprType::Mul,
left: Value::Int(make_value_node(2)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(2))))
}),
Val::Int(4)), Val::Int(4)),
(Expression::Mul(BinaryExpression(Value::Float(make_value_node(2.0)), (Expression::Binary(
Box::new(Expression::Simple(Value::Float(make_value_node(2.0)))))), BinaryExpression{
kind: BinaryExprType::Mul,
left: Value::Float(make_value_node(2.0)),
right: Box::new(Expression::Simple(Value::Float(make_value_node(2.0))))
}),
Val::Float(4.0)), Val::Float(4.0)),
], b); ], b);
} }
@ -660,8 +678,12 @@ mod test {
fn test_eval_mul_expr_fail() { fn test_eval_mul_expr_fail() {
let b = Builder::new(); let b = Builder::new();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Mul(BinaryExpression(Value::Float(make_value_node(2.0)), (Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(20)))))), BinaryExpression{
kind: BinaryExprType::Mul,
left: Value::Float(make_value_node(2.0)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(20))))
}),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -670,11 +692,19 @@ mod test {
fn test_eval_subtract_expr() { fn test_eval_subtract_expr() {
let b = Builder::new(); let b = Builder::new();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Sub(BinaryExpression(Value::Int(make_value_node(2)), (Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))), BinaryExpression{
kind: BinaryExprType::Sub,
left: Value::Int(make_value_node(2)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
}),
Val::Int(1)), Val::Int(1)),
(Expression::Sub(BinaryExpression(Value::Float(make_value_node(2.0)), (Expression::Binary(
Box::new(Expression::Simple(Value::Float(make_value_node(1.0)))))), BinaryExpression{
kind: BinaryExprType::Sub,
left: Value::Float(make_value_node(2.0)),
right: Box::new(Expression::Simple(Value::Float(make_value_node(1.0))))
}),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -684,8 +714,12 @@ mod test {
fn test_eval_subtract_expr_fail() { fn test_eval_subtract_expr_fail() {
let b = Builder::new(); let b = Builder::new();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Sub(BinaryExpression(Value::Float(make_value_node(2.0)), (Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))), BinaryExpression{
kind: BinaryExprType::Sub,
left: Value::Float(make_value_node(2.0)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(2))))
}),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -694,14 +728,26 @@ mod test {
fn test_eval_add_expr() { fn test_eval_add_expr() {
let b = Builder::new(); let b = Builder::new();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Add(BinaryExpression(Value::Int(make_value_node(1)), (Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))), BinaryExpression{
kind: BinaryExprType::Add,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1))))
}),
Val::Int(2)), Val::Int(2)),
(Expression::Add(BinaryExpression(Value::Float(make_value_node(1.0)), (Expression::Binary(
Box::new(Expression::Simple(Value::Float(make_value_node(1.0)))))), BinaryExpression{
kind: BinaryExprType::Add,
left: Value::Float(make_value_node(1.0)),
right: Box::new(Expression::Simple(Value::Float(make_value_node(1.0)))),
}),
Val::Float(2.0)), Val::Float(2.0)),
(Expression::Add(BinaryExpression(Value::String(make_value_node("foo".to_string())), (Expression::Binary(
Box::new(Expression::Simple(Value::String(make_value_node("bar".to_string())))))), BinaryExpression{
kind: BinaryExprType::Add,
left: Value::String(make_value_node("foo".to_string())),
right: Box::new(Expression::Simple(Value::String(make_value_node("bar".to_string())))),
}),
Val::String("foobar".to_string())), Val::String("foobar".to_string())),
], b); ], b);
} }
@ -711,8 +757,12 @@ mod test {
fn test_eval_add_expr_fail() { fn test_eval_add_expr_fail() {
let b = Builder::new(); let b = Builder::new();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Add(BinaryExpression(Value::Float(make_value_node(2.0)), (Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))), BinaryExpression{
kind: BinaryExprType::Add,
left: Value::Float(make_value_node(2.0)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(2)))),
}),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }

120
src/parse.rs
View File

@ -199,8 +199,12 @@ named!(simple_expression<Expression>,
) )
); );
fn tuple_to_add_expression(tpl: (Value, Expression)) -> ParseResult<Expression> { fn tuple_to_binary_expression(tpl: (BinaryExprType, Value, Expression)) -> ParseResult<Expression> {
Ok(Expression::Add(BinaryExpression(tpl.0, Box::new(tpl.1)))) Ok(Expression::Binary(BinaryExpression{
kind: tpl.0,
left: tpl.1,
right: Box::new(tpl.2),
}))
} }
named!(add_expression<Expression>, named!(add_expression<Expression>,
@ -209,57 +213,45 @@ named!(add_expression<Expression>,
left: value >> left: value >>
ws!(plus) >> ws!(plus) >>
right: expression >> right: expression >>
(left, right) (BinaryExprType::Add, left, right)
), ),
tuple_to_add_expression tuple_to_binary_expression
) )
); );
fn tuple_to_sub_expression(tpl: (Value, Expression)) -> ParseResult<Expression> {
Ok(Expression::Sub(BinaryExpression(tpl.0, Box::new(tpl.1))))
}
named!(sub_expression<Expression>, named!(sub_expression<Expression>,
map_res!( map_res!(
do_parse!( do_parse!(
left: value >> left: value >>
ws!(minus) >> ws!(minus) >>
right: expression >> right: expression >>
(left, right) (BinaryExprType::Sub, left, right)
), ),
tuple_to_sub_expression tuple_to_binary_expression
) )
); );
fn tuple_to_mul_expression(tpl: (Value, Expression)) -> ParseResult<Expression> {
Ok(Expression::Mul(BinaryExpression(tpl.0, Box::new(tpl.1))))
}
named!(mul_expression<Expression>, named!(mul_expression<Expression>,
map_res!( map_res!(
do_parse!( do_parse!(
left: value >> left: value >>
ws!(mul) >> ws!(mul) >>
right: expression >> right: expression >>
(left, right) (BinaryExprType::Mul, left, right)
), ),
tuple_to_mul_expression tuple_to_binary_expression
) )
); );
fn tuple_to_div_expression(tpl: (Value, Expression)) -> ParseResult<Expression> {
Ok(Expression::Div(BinaryExpression(tpl.0, Box::new(tpl.1))))
}
named!(div_expression<Expression>, named!(div_expression<Expression>,
map_res!( map_res!(
do_parse!( do_parse!(
left: value >> left: value >>
ws!(div) >> ws!(div) >>
right: expression >> right: expression >>
(left, right) (BinaryExprType::Div, left, right)
), ),
tuple_to_div_expression tuple_to_binary_expression
) )
); );
@ -623,37 +615,61 @@ mod test {
IResult::Done(&b""[..], Expression::Simple(Value::Symbol(make_value_node("foo".to_string()))))); IResult::Done(&b""[..], Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))));
assert_eq!(expression(&b"1 + 1"[..]), assert_eq!(expression(&b"1 + 1"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Add(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); kind: BinaryExprType::Add,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})));
assert_eq!(expression(&b"1 - 1"[..]), assert_eq!(expression(&b"1 - 1"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Sub(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); kind: BinaryExprType::Sub,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})));
assert_eq!(expression(&b"1 * 1"[..]), assert_eq!(expression(&b"1 * 1"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Mul(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); kind: BinaryExprType::Mul,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})));
assert_eq!(expression(&b"1 / 1"[..]), assert_eq!(expression(&b"1 / 1"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Div(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); kind: BinaryExprType::Div,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})));
assert_eq!(expression(&b"1+1"[..]), assert_eq!(expression(&b"1+1"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Add(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); kind: BinaryExprType::Add,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})));
assert_eq!(expression(&b"1-1"[..]), assert_eq!(expression(&b"1-1"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Sub(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); kind: BinaryExprType::Sub,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})));
assert_eq!(expression(&b"1*1"[..]), assert_eq!(expression(&b"1*1"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Mul(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); kind: BinaryExprType::Mul,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})));
assert_eq!(expression(&b"1/1"[..]), assert_eq!(expression(&b"1/1"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Div(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); kind: BinaryExprType::Div,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})));
assert_eq!(expression(&b"macro (arg1, arg2) => { foo = arg1 }"[..]), assert_eq!(expression(&b"macro (arg1, arg2) => { foo = arg1 }"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Macro(MacroDef{ Expression::Macro(MacroDef{
@ -693,9 +709,12 @@ mod test {
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Grouped( Expression::Grouped(
Box::new( Box::new(
Expression::Add( Expression::Binary(
BinaryExpression(Value::Int(make_value_node(1)), BinaryExpression{
Box::new(Expression::Simple(Value::Int(make_value_node(1))))) kind: BinaryExprType::Add,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
}
) )
) )
) )
@ -851,10 +870,13 @@ mod test {
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Grouped( Expression::Grouped(
Box::new( Box::new(
Expression::Add( Expression::Binary(
BinaryExpression(Value::Int(make_value_node(1)), BinaryExpression{
Box::new(Expression::Simple( kind: BinaryExprType::Add,
Value::Int(make_value_node(1))))) left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(
Value::Int(make_value_node(1)))),
}
) )
) )
) )
@ -963,8 +985,12 @@ mod test {
value: Expression::Simple(Value::Int(make_value_node(1))) value: Expression::Simple(Value::Int(make_value_node(1)))
}, },
Statement::Expression( Statement::Expression(
Expression::Add(BinaryExpression(Value::Int(make_value_node(1)), Expression::Binary(
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))) BinaryExpression{
kind: BinaryExprType::Add,
left: Value::Int(make_value_node(1)),
right: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
})
) )
]); ]);
} }