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

Add datastructure to support tracking position of Value nodes in the AST.

Browse Source
This commit is contained in:
Jeremy Wall 2017-09-18 20:12:34 -05:00
parent 6c3662d361
commit b3677861c6
3 changed files with 231 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/ast.rs
View File

@ -14,20 +14,53 @@
use std::collections::HashSet; use std::collections::HashSet;
use std::borrow::Borrow; use std::borrow::Borrow;
#[derive(Debug,PartialEq,Clone)]
pub struct Position {
pub line: usize,
pub column: usize,
}
pub type FieldList = Vec<(String, Expression)>; // str is expected to be a symbol pub type FieldList = Vec<(String, Expression)>; // str is expected to be a symbol
pub type SelectorList = Vec<String>; // str is expected to always be a symbol. pub type SelectorList = Vec<String>; // str is expected to always be a symbol.
#[derive(Debug,PartialEq,Clone)]
pub struct LocatedNode<T> {
pub pos: Option<Position>,
pub val: T,
}
impl<T> LocatedNode<T> {
pub fn new(v: T) -> Self {
Self {
pos: None,
val: v,
}
}
pub fn new_with_pos(v: T, pos: Position) -> Self {
Self {
pos: Some(pos),
val: v,
}
}
}
pub fn make_value_node<T>(v: T) -> LocatedNode<T> {
LocatedNode::new(v)
}
/// Value represents a Value in the UCG parsed AST. /// Value represents a Value in the UCG parsed AST.
#[derive(Debug,PartialEq,Clone)] #[derive(Debug,PartialEq,Clone)]
pub enum Value { pub enum Value {
// Constant Values // Constant Values
Int(i64), Int(LocatedNode<i64>),
Float(f64), Float(LocatedNode<f64>),
String(String), String(LocatedNode<String>),
Symbol(String), Symbol(LocatedNode<String>),
// Complex Values // Complex Values
Tuple(FieldList), Tuple(LocatedNode<FieldList>),
Selector(SelectorList), Selector(LocatedNode<SelectorList>),
} }
impl Value { impl Value {
@ -56,12 +89,12 @@ impl Value {
pub fn to_string(&self) -> String { pub fn to_string(&self) -> String {
match self { match self {
&Value::Int(ref i) => format!("{}", i), &Value::Int(ref i) => format!("{}", i.val),
&Value::Float(ref f) => format!("{}", f), &Value::Float(ref f) => format!("{}", f.val),
&Value::String(ref s) => format!("{}", s), &Value::String(ref s) => format!("{}", s.val),
&Value::Symbol(ref s) => format!("{}", s), &Value::Symbol(ref s) => format!("{}", s.val),
&Value::Tuple(ref fs) => format!("{}", Self::fields_to_string(fs)), &Value::Tuple(ref fs) => format!("{}", Self::fields_to_string(&fs.val)),
&Value::Selector(ref v) => v.join("."), &Value::Selector(ref v) => v.val.join("."),
} }
} }
} }
@ -99,12 +132,13 @@ impl MacroDef {
if let &Value::Symbol(ref name) = val { if let &Value::Symbol(ref name) = val {
let mut ok = true; let mut ok = true;
for arg in self.argdefs.iter() { for arg in self.argdefs.iter() {
ok &= arg == name ok &= arg == &name.val
} }
if !ok { if !ok {
bad_symbols.insert(name.clone()); bad_symbols.insert(name.val.clone());
} }
} else if let &Value::Selector(ref list) = val { } else if let &Value::Selector(ref sel_node) = val {
let list = &sel_node.val;
let mut ok = true; let mut ok = true;
if list.len() > 0 { if list.len() > 0 {
// We only look to see if the first selector item exists. // We only look to see if the first selector item exists.
@ -119,7 +153,8 @@ impl MacroDef {
bad_symbols.insert(list[0].clone()); bad_symbols.insert(list[0].clone());
} }
} }
} else if let &Value::Tuple(ref fields) = val { } else if let &Value::Tuple(ref tuple_node) = val {
let fields = &tuple_node.val;
for &(_, ref expr) in fields.iter() { for &(_, ref expr) in fields.iter() {
stack.push(expr); stack.push(expr);
} }
@ -257,8 +292,8 @@ mod ast_test {
], ],
fields: vec![ fields: vec![
("f1".to_string(), Expression::Add(BinaryExpression( ("f1".to_string(), Expression::Add(BinaryExpression(
Value::Symbol("foo".to_string()), Value::Symbol(make_value_node("foo".to_string())),
Box::new(Expression::Simple(Value::Int(1)))))), Box::new(Expression::Simple(Value::Int(make_value_node(1))))))),
], ],
}; };
assert!(def.validate_symbols().unwrap() == ()); assert!(def.validate_symbols().unwrap() == ());
@ -272,9 +307,10 @@ mod ast_test {
], ],
fields: vec![ fields: vec![
("f1".to_string(), Expression::Add(BinaryExpression( ("f1".to_string(), Expression::Add(BinaryExpression(
Value::Symbol("bar".to_string()), Value::Symbol(make_value_node("bar".to_string())),
Box::new(Expression::Simple(Value::Int(1)))))), Box::new(Expression::Simple(Value::Int(make_value_node(1))))))),
], ],
}; };
let mut expected = HashSet::new(); let mut expected = HashSet::new();
expected.insert("bar".to_string()); expected.insert("bar".to_string());
@ -289,8 +325,8 @@ mod ast_test {
], ],
fields: vec![ fields: vec![
("f1".to_string(), Expression::Add(BinaryExpression( ("f1".to_string(), Expression::Add(BinaryExpression(
Value::Selector(vec!["foo".to_string(), "quux".to_string()]), Value::Selector(make_value_node(vec!["foo".to_string(), "quux".to_string()])),
Box::new(Expression::Simple(Value::Int(1)))))), Box::new(Expression::Simple(Value::Int(make_value_node(1))))))),
], ],
}; };
assert!(def.validate_symbols().unwrap() == ()); assert!(def.validate_symbols().unwrap() == ());
@ -304,8 +340,8 @@ mod ast_test {
], ],
fields: vec![ fields: vec![
("f1".to_string(), Expression::Add(BinaryExpression( ("f1".to_string(), Expression::Add(BinaryExpression(
Value::Selector(vec!["bar".to_string(), "quux".to_string()]), Value::Selector(make_value_node(vec!["bar".to_string(), "quux".to_string()])),
Box::new(Expression::Simple(Value::Int(1)))))), Box::new(Expression::Simple(Value::Int(make_value_node(1))))))),
], ],
}; };
let mut expected = HashSet::new(); let mut expected = HashSet::new();

134
src/build.rs
View File

@ -220,14 +220,15 @@ impl Builder {
/// new_builder constructs Builder with initialized fields ready to parse. /// new_builder constructs Builder with initialized fields ready to parse.
fn value_to_val(&self, v: Value) -> Result<Rc<Val>, Box<Error>> { fn value_to_val(&self, v: Value) -> Result<Rc<Val>, Box<Error>> {
match v { match v {
Value::Int(i) => Ok(Rc::new(Val::Int(i))), Value::Int(i) => Ok(Rc::new(Val::Int(i.val))),
Value::Float(f) => Ok(Rc::new(Val::Float(f))), Value::Float(f) => Ok(Rc::new(Val::Float(f.val))),
Value::String(s) => Ok(Rc::new(Val::String(s.to_string()))), Value::String(s) => Ok(Rc::new(Val::String(s.val.to_string()))),
Value::Symbol(s) => { Value::Symbol(s) => {
self.lookup_sym(&s).ok_or(Box::new( self.lookup_sym(&s.val).ok_or(Box::new(
BuildError::NoSuchSymbol(format!("Unable to find {}", s)))) BuildError::NoSuchSymbol(format!("Unable to find {}", s.val))))
}, },
Value::Tuple(mut fields) => { Value::Tuple(mut tuple_node) => {
let fields = &mut tuple_node.val;
let mut new_fields = Vec::new(); let mut new_fields = Vec::new();
for (name, expr) in fields.drain(0..) { for (name, expr) in fields.drain(0..) {
let val = try!(self.eval_expr(expr)); let val = try!(self.eval_expr(expr));
@ -236,8 +237,8 @@ impl Builder {
new_fields.sort_by(|a, b| a.0.cmp(&b.0)); new_fields.sort_by(|a, b| a.0.cmp(&b.0));
Ok(Rc::new(Val::Tuple(new_fields))) Ok(Rc::new(Val::Tuple(new_fields)))
}, },
Value::Selector(selector_list) => { Value::Selector(selector_list_node) => {
self.lookup_selector(selector_list) self.lookup_selector(selector_list_node.val)
}, },
} }
} }
@ -619,9 +620,11 @@ 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(2), Box::new(Expression::Simple(Value::Int(2))))), (Expression::Div(BinaryExpression(Value::Int(make_value_node(2)),
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))),
Val::Int(1)), Val::Int(1)),
(Expression::Div(BinaryExpression(Value::Float(2.0), Box::new(Expression::Simple(Value::Float(2.0))))), (Expression::Div(BinaryExpression(Value::Float(make_value_node(2.0)),
Box::new(Expression::Simple(Value::Float(make_value_node(2.0)))))),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -631,7 +634,8 @@ 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(2.0), Box::new(Expression::Simple(Value::Int(2))))), (Expression::Div(BinaryExpression(Value::Float(make_value_node(2.0)),
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -640,9 +644,11 @@ 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(2), Box::new(Expression::Simple(Value::Int(2))))), (Expression::Mul(BinaryExpression(Value::Int(make_value_node(2)),
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))),
Val::Int(4)), Val::Int(4)),
(Expression::Mul(BinaryExpression(Value::Float(2.0), Box::new(Expression::Simple(Value::Float(2.0))))), (Expression::Mul(BinaryExpression(Value::Float(make_value_node(2.0)),
Box::new(Expression::Simple(Value::Float(make_value_node(2.0)))))),
Val::Float(4.0)), Val::Float(4.0)),
], b); ], b);
} }
@ -652,7 +658,8 @@ 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(2.0), Box::new(Expression::Simple(Value::Int(2))))), (Expression::Mul(BinaryExpression(Value::Float(make_value_node(2.0)),
Box::new(Expression::Simple(Value::Int(make_value_node(20)))))),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -661,9 +668,11 @@ 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(2), Box::new(Expression::Simple(Value::Int(1))))), (Expression::Sub(BinaryExpression(Value::Int(make_value_node(2)),
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))),
Val::Int(1)), Val::Int(1)),
(Expression::Sub(BinaryExpression(Value::Float(2.0), Box::new(Expression::Simple(Value::Float(1.0))))), (Expression::Sub(BinaryExpression(Value::Float(make_value_node(2.0)),
Box::new(Expression::Simple(Value::Float(make_value_node(1.0)))))),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -673,7 +682,8 @@ 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(2.0), Box::new(Expression::Simple(Value::Int(2))))), (Expression::Sub(BinaryExpression(Value::Float(make_value_node(2.0)),
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -682,11 +692,14 @@ 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(1), Box::new(Expression::Simple(Value::Int(1))))), (Expression::Add(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(make_value_node(1)))))),
Val::Int(2)), Val::Int(2)),
(Expression::Add(BinaryExpression(Value::Float(1.0), Box::new(Expression::Simple(Value::Float(1.0))))), (Expression::Add(BinaryExpression(Value::Float(make_value_node(1.0)),
Box::new(Expression::Simple(Value::Float(make_value_node(1.0)))))),
Val::Float(2.0)), Val::Float(2.0)),
(Expression::Add(BinaryExpression(Value::String("foo".to_string()), Box::new(Expression::Simple(Value::String("bar".to_string()))))), (Expression::Add(BinaryExpression(Value::String(make_value_node("foo".to_string())),
Box::new(Expression::Simple(Value::String(make_value_node("bar".to_string())))))),
Val::String("foobar".to_string())), Val::String("foobar".to_string())),
], b); ], b);
} }
@ -696,7 +709,8 @@ 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(2.0), Box::new(Expression::Simple(Value::Int(2))))), (Expression::Add(BinaryExpression(Value::Float(make_value_node(2.0)),
Box::new(Expression::Simple(Value::Int(make_value_node(2)))))),
Val::Float(1.0)), Val::Float(1.0)),
], b); ], b);
} }
@ -704,12 +718,12 @@ mod test {
#[test] #[test]
fn test_eval_simple_expr() { fn test_eval_simple_expr() {
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Simple(Value::Int(1)), Val::Int(1)), (Expression::Simple(Value::Int(make_value_node(1))), Val::Int(1)),
(Expression::Simple(Value::Float(2.0)), Val::Float(2.0)), (Expression::Simple(Value::Float(make_value_node(2.0))), Val::Float(2.0)),
(Expression::Simple(Value::String("foo".to_string())), (Expression::Simple(Value::String(make_value_node("foo".to_string()))),
Val::String("foo".to_string())), Val::String("foo".to_string())),
(Expression::Simple(Value::Tuple(vec![("bar".to_string(), (Expression::Simple(Value::Tuple(make_value_node(vec![("bar".to_string(),
Expression::Simple(Value::Int(1)))])), Expression::Simple(Value::Int(make_value_node(1))))]))),
Val::Tuple(vec![("bar".to_string(), Rc::new(Val::Int(1)))])), Val::Tuple(vec![("bar".to_string(), Rc::new(Val::Int(1)))])),
], Builder::new()); ], Builder::new());
} }
@ -719,7 +733,7 @@ mod test {
let mut b = Builder::new(); let mut b = Builder::new();
b.out.entry("var1".to_string()).or_insert(Rc::new(Val::Int(1))); b.out.entry("var1".to_string()).or_insert(Rc::new(Val::Int(1)));
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Simple(Value::Symbol("var1".to_string())), Val::Int(1)), (Expression::Simple(Value::Symbol(make_value_node("var1".to_string()))), Val::Int(1)),
], b); ], b);
} }
@ -727,7 +741,7 @@ mod test {
fn test_eval_simple_lookup_error() { fn test_eval_simple_lookup_error() {
let mut b = Builder::new(); let mut b = Builder::new();
b.out.entry("var1".to_string()).or_insert(Rc::new(Val::Int(1))); b.out.entry("var1".to_string()).or_insert(Rc::new(Val::Int(1)));
assert!(b.eval_expr(Expression::Simple(Value::Symbol("var".to_string()))).is_err()); assert!(b.eval_expr(Expression::Simple(Value::Symbol(make_value_node("var".to_string())))).is_err());
} }
#[test] #[test]
@ -746,7 +760,7 @@ mod test {
("lvl1".to_string(), Rc::new(Val::Int(4))) ("lvl1".to_string(), Rc::new(Val::Int(4)))
]))); ])));
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Simple(Value::Selector(vec!["var1".to_string()])), Val::Tuple( (Expression::Simple(Value::Selector(make_value_node(vec!["var1".to_string()]))), Val::Tuple(
vec![ vec![
("lvl1".to_string(), Rc::new(Val::Tuple( ("lvl1".to_string(), Rc::new(Val::Tuple(
vec![ vec![
@ -755,21 +769,21 @@ mod test {
))), ))),
] ]
)), )),
(Expression::Simple(Value::Selector(vec!["var1".to_string(), (Expression::Simple(Value::Selector(make_value_node(vec!["var1".to_string(),
"lvl1".to_string()])), "lvl1".to_string()]))),
Val::Tuple( Val::Tuple(
vec![ vec![
("lvl2".to_string(), Rc::new(Val::Int(3))), ("lvl2".to_string(), Rc::new(Val::Int(3))),
] ]
)), )),
(Expression::Simple(Value::Selector(vec!["var1".to_string(), (Expression::Simple(Value::Selector(make_value_node(vec!["var1".to_string(),
"lvl1".to_string(), "lvl1".to_string(),
"lvl2".to_string()])), "lvl2".to_string()]))),
Val::Int(3)), Val::Int(3)),
(Expression::Simple(Value::Selector(vec!["var2".to_string()])), (Expression::Simple(Value::Selector(make_value_node(vec!["var2".to_string()]))),
Val::Int(2)), Val::Int(2)),
(Expression::Simple(Value::Selector(vec!["var3".to_string(), (Expression::Simple(Value::Selector(make_value_node(vec!["var3".to_string(),
"lvl1".to_string()])), "lvl1".to_string()]))),
Val::Int(4)), Val::Int(4)),
], b); ], b);
} }
@ -805,7 +819,7 @@ mod test {
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Copy(vec!["tpl1".to_string()], (Expression::Copy(vec!["tpl1".to_string()],
vec![("fld1".to_string(), vec![("fld1".to_string(),
Expression::Simple(Value::String("2".to_string())))]), Expression::Simple(Value::String(make_value_node("2".to_string()))))]),
Val::Tuple( Val::Tuple(
vec![ vec![
("fld1".to_string(), Rc::new(Val::String("2".to_string()))), ("fld1".to_string(), Rc::new(Val::String("2".to_string()))),
@ -826,7 +840,7 @@ mod test {
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Copy(vec!["tpl1".to_string()], (Expression::Copy(vec!["tpl1".to_string()],
vec![("fld2".to_string(), vec![("fld2".to_string(),
Expression::Simple(Value::String("2".to_string())))]), Expression::Simple(Value::String(make_value_node("2".to_string()))))]),
// Add a new field to the copy // Add a new field to the copy
Val::Tuple( Val::Tuple(
// NOTE(jwall): The order of these is important in order to ensure // NOTE(jwall): The order of these is important in order to ensure
@ -841,9 +855,9 @@ mod test {
(Expression::Copy(vec!["tpl1".to_string()], (Expression::Copy(vec!["tpl1".to_string()],
vec![ vec![
("fld1".to_string(), ("fld1".to_string(),
Expression::Simple(Value::Int(3))), Expression::Simple(Value::Int(make_value_node(3)))),
("fld2".to_string(), ("fld2".to_string(),
Expression::Simple(Value::String("2".to_string()))), Expression::Simple(Value::String(make_value_node("2".to_string())))),
]), ]),
Val::Tuple( Val::Tuple(
vec![ vec![
@ -852,7 +866,7 @@ mod test {
], ],
)), )),
// The source tuple is still unmodified. // The source tuple is still unmodified.
(Expression::Simple(Value::Selector(vec!["tpl1".to_string()])), (Expression::Simple(Value::Selector(make_value_node(vec!["tpl1".to_string()]))),
Val::Tuple( Val::Tuple(
vec![ vec![
("fld1".to_string(), Rc::new(Val::Int(1))), ("fld1".to_string(), Rc::new(Val::Int(1))),
@ -867,13 +881,13 @@ mod test {
b.out.entry("tstmac".to_string()).or_insert(Rc::new(Val::Macro(MacroDef{ b.out.entry("tstmac".to_string()).or_insert(Rc::new(Val::Macro(MacroDef{
argdefs: vec!["arg1".to_string()], argdefs: vec!["arg1".to_string()],
fields: vec![ fields: vec![
("foo".to_string(), Expression::Simple(Value::Symbol("arg1".to_string()))), ("foo".to_string(), Expression::Simple(Value::Symbol(make_value_node("arg1".to_string())))),
], ],
}))); })));
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Call(CallDef{ (Expression::Call(CallDef{
macroref: vec!["tstmac".to_string()], macroref: vec!["tstmac".to_string()],
arglist: vec![Expression::Simple(Value::String("bar".to_string()))], arglist: vec![Expression::Simple(Value::String(make_value_node("bar".to_string())))],
}), }),
Val::Tuple(vec![ Val::Tuple(vec![
("foo".to_string(), Rc::new(Val::String("bar".to_string()))), ("foo".to_string(), Rc::new(Val::String("bar".to_string()))),
@ -889,13 +903,13 @@ mod test {
b.out.entry("tstmac".to_string()).or_insert(Rc::new(Val::Macro(MacroDef{ b.out.entry("tstmac".to_string()).or_insert(Rc::new(Val::Macro(MacroDef{
argdefs: vec!["arg2".to_string()], argdefs: vec!["arg2".to_string()],
fields: vec![ fields: vec![
("foo".to_string(), Expression::Simple(Value::Symbol("arg1".to_string()))), ("foo".to_string(), Expression::Simple(Value::Symbol(make_value_node("arg1".to_string())))),
], ],
}))); })));
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Call(CallDef{ (Expression::Call(CallDef{
macroref: vec!["tstmac".to_string()], macroref: vec!["tstmac".to_string()],
arglist: vec![Expression::Simple(Value::String("bar".to_string()))], arglist: vec![Expression::Simple(Value::String(make_value_node("bar".to_string())))],
}), }),
Val::Tuple(vec![ Val::Tuple(vec![
("foo".to_string(), Rc::new(Val::String("bar".to_string()))), ("foo".to_string(), Rc::new(Val::String("bar".to_string()))),
@ -910,20 +924,20 @@ mod test {
b.out.entry("baz".to_string()).or_insert(Rc::new(Val::String("boo".to_string()))); b.out.entry("baz".to_string()).or_insert(Rc::new(Val::String("boo".to_string())));
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Select(SelectDef{ (Expression::Select(SelectDef{
val: Box::new(Expression::Simple(Value::Symbol("foo".to_string()))), val: Box::new(Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))),
default: Box::new(Expression::Simple(Value::Int(1))), default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
tuple: vec![ tuple: vec![
("bar".to_string(), Expression::Simple(Value::Int(2))), ("bar".to_string(), Expression::Simple(Value::Int(make_value_node(2)))),
("quux".to_string(), Expression::Simple(Value::String("2".to_string()))), ("quux".to_string(), Expression::Simple(Value::String(make_value_node("2".to_string())))),
], ],
}), }),
Val::Int(2)), Val::Int(2)),
(Expression::Select(SelectDef{ (Expression::Select(SelectDef{
val: Box::new(Expression::Simple(Value::Symbol("baz".to_string()))), val: Box::new(Expression::Simple(Value::Symbol(make_value_node("baz".to_string())))),
default: Box::new(Expression::Simple(Value::Int(1))), default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
tuple: vec![ tuple: vec![
("bar".to_string(), Expression::Simple(Value::Int(2))), ("bar".to_string(), Expression::Simple(Value::Int(make_value_node(2)))),
("quux".to_string(), Expression::Simple(Value::String("2".to_string()))), ("quux".to_string(), Expression::Simple(Value::String(make_value_node("2".to_string())))),
], ],
}), }),
// If the field doesn't exist then we get the default. // If the field doesn't exist then we get the default.
@ -938,11 +952,11 @@ mod test {
b.out.entry("foo".to_string()).or_insert(Rc::new(Val::Int(4))); b.out.entry("foo".to_string()).or_insert(Rc::new(Val::Int(4)));
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Select(SelectDef{ (Expression::Select(SelectDef{
val: Box::new(Expression::Simple(Value::Symbol("foo".to_string()))), val: Box::new(Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))),
default: Box::new(Expression::Simple(Value::Int(1))), default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
tuple: vec![ tuple: vec![
("bar".to_string(), Expression::Simple(Value::Int(2))), ("bar".to_string(), Expression::Simple(Value::Int(make_value_node(2)))),
("quux".to_string(), Expression::Simple(Value::String("2".to_string()))), ("quux".to_string(), Expression::Simple(Value::String(make_value_node("2".to_string())))),
], ],
}), }),
Val::Int(2)), Val::Int(2)),
@ -954,10 +968,10 @@ mod test {
let mut b = Builder::new(); let mut b = Builder::new();
b.build_stmt(Statement::Let{ b.build_stmt(Statement::Let{
name:"foo".to_string(), name:"foo".to_string(),
value: Expression::Simple(Value::String("bar".to_string())), value: Expression::Simple(Value::String(make_value_node("bar".to_string()))),
}).unwrap(); }).unwrap();
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Simple(Value::Symbol("foo".to_string())), (Expression::Simple(Value::Symbol(make_value_node("foo".to_string()))),
Val::String("bar".to_string())), Val::String("bar".to_string())),
], b); ], b);
} }
@ -979,7 +993,7 @@ mod test {
]))), ]))),
]))); ])));
test_expr_to_val(vec![ test_expr_to_val(vec![
(Expression::Simple(Value::Symbol("foo".to_string())), (Expression::Simple(Value::Symbol(make_value_node("foo".to_string()))),
Val::Tuple(vec![ Val::Tuple(vec![
("bar".to_string(), Rc::new(Val::Tuple(vec![ ("bar".to_string(), Rc::new(Val::Tuple(vec![
("quux".to_string(), Rc::new(Val::Int(1))), ("quux".to_string(), Rc::new(Val::Int(1))),

193
src/parse.rs
View File

@ -53,7 +53,6 @@ named!(fatcomma, tag!("=>"));
fn is_symbol_char(c: u8) -> bool { fn is_symbol_char(c: u8) -> bool {
is_alphanumeric(c) || c == '-' as u8 || c == '_' as u8 is_alphanumeric(c) || c == '-' as u8 || c == '_' as u8
} }
// a field is the building block of symbols and tuple field names. // a field is the building block of symbols and tuple field names.
named!(field<String>, named!(field<String>,
map_res!(preceded!(peek!(alpha), take_while!(is_symbol_char)), map_res!(preceded!(peek!(alpha), take_while!(is_symbol_char)),
@ -62,7 +61,7 @@ named!(field<String>,
); );
fn symbol_to_value(s: String) -> ParseResult<Value> { fn symbol_to_value(s: String) -> ParseResult<Value> {
Ok(Value::Symbol(s)) Ok(Value::Symbol(make_value_node(s)))
} }
// symbol is a bare unquoted field. // symbol is a bare unquoted field.
@ -76,7 +75,7 @@ named!(quoted<String>,
); );
fn str_to_value(s: String) -> ParseResult<Value> { fn str_to_value(s: String) -> ParseResult<Value> {
Ok(Value::String(s)) Ok(Value::String(make_value_node(s)))
} }
// quoted_value is a quoted string. // quoted_value is a quoted string.
@ -95,7 +94,7 @@ fn triple_to_number(v: (Option<&[u8]>, Option<&[u8]>, Option<&[u8]>))
let has_dot = v.1.is_some(); let has_dot = v.1.is_some();
if v.0.is_some() && !has_dot && v.2.is_none() { if v.0.is_some() && !has_dot && v.2.is_none() {
return Ok(Value::Int(try!(FromStr::from_str(pref)))); return Ok(Value::Int(make_value_node(try!(FromStr::from_str(pref)))));
} }
let suf = match v.2 { let suf = match v.2 {
@ -105,7 +104,7 @@ fn triple_to_number(v: (Option<&[u8]>, Option<&[u8]>, Option<&[u8]>))
let to_parse = pref.to_string() + "." + suf; let to_parse = pref.to_string() + "." + suf;
let f = try!(FromStr::from_str(&to_parse)); let f = try!(FromStr::from_str(&to_parse));
return Ok(Value::Float(f)); return Ok(Value::Float(make_value_node(f)));
} }
// NOTE(jwall): HERE THERE BE DRAGONS. The order for these matters // NOTE(jwall): HERE THERE BE DRAGONS. The order for these matters
@ -165,7 +164,7 @@ named!(
// Helper function to make the return types work for down below. // Helper function to make the return types work for down below.
fn vec_to_tuple(v: FieldList) -> ParseResult<Value> { fn vec_to_tuple(v: FieldList) -> ParseResult<Value> {
Ok(Value::Tuple(v)) Ok(Value::Tuple(make_value_node(v)))
} }
named!(field_list<FieldList>, named!(field_list<FieldList>,
@ -299,7 +298,7 @@ fn tuple_to_macro(mut t: (Vec<Value>, Value)) -> ParseResult<Expression> {
Value::Tuple(v) => { Value::Tuple(v) => {
Ok(Expression::Macro(MacroDef { Ok(Expression::Macro(MacroDef {
argdefs: t.0.drain(0..).map(|s| s.to_string()).collect(), argdefs: t.0.drain(0..).map(|s| s.to_string()).collect(),
fields: v, fields: v.val,
})) }))
} }
// TODO(jwall): Show a better version of the unexpected parsed value. // TODO(jwall): Show a better version of the unexpected parsed value.
@ -333,7 +332,7 @@ fn tuple_to_select(t: (Expression, Expression, Value))
Ok(Expression::Select(SelectDef{ Ok(Expression::Select(SelectDef{
val: Box::new(t.0), val: Box::new(t.0),
default: Box::new(t.1), default: Box::new(t.1),
tuple: v, tuple: v.val,
})) }))
} }
// TODO(jwall): Show a better version of the unexpected parsed value. // TODO(jwall): Show a better version of the unexpected parsed value.
@ -377,7 +376,7 @@ named!(format_expression<Expression>,
fn tuple_to_call(t: (Value, Vec<Expression>)) -> ParseResult<Expression> { fn tuple_to_call(t: (Value, Vec<Expression>)) -> ParseResult<Expression> {
if let Value::Selector(sl) = t.0 { if let Value::Selector(sl) = t.0 {
Ok(Expression::Call(CallDef{ Ok(Expression::Call(CallDef{
macroref: sl, macroref: sl.val,
arglist: t.1, arglist: t.1,
})) }))
} else { } else {
@ -386,7 +385,7 @@ fn tuple_to_call(t: (Value, Vec<Expression>)) -> ParseResult<Expression> {
} }
fn vec_to_selector_value(v: SelectorList) -> ParseResult<Value> { fn vec_to_selector_value(v: SelectorList) -> ParseResult<Value> {
Ok(Value::Selector(v)) Ok(Value::Selector(make_value_node(v)))
} }
named!(selector_value<Value>, named!(selector_value<Value>,
@ -501,14 +500,16 @@ named!(pub parse<Vec<Statement> >, many1!(ws!(statement)));
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use std::str::from_utf8; use std::str::from_utf8;
use super::{Statement, Expression, Value, MacroDef, SelectDef, CallDef}; use super::{Statement, Expression, Value, MacroDef, SelectDef, CallDef};
use super::{number, symbol, parse, field_value, tuple, grouped_expression}; use super::{number, symbol, parse, field_value, tuple, grouped_expression};
use super::{arglist, copy_expression, macro_expression, select_expression}; use super::{arglist, copy_expression, macro_expression, select_expression};
use super::{format_expression, call_expression, expression}; use super::{format_expression, call_expression, expression};
use super::{expression_statement, let_statement, import_statement, statement}; use super::{expression_statement, let_statement, import_statement, statement};
use nom::IResult;
use ast::*; use ast::*;
use nom::IResult;
#[test] #[test]
fn test_statement_parse() { fn test_statement_parse() {
assert_eq!(statement(&b"import \"foo\" as foo;"[..]), assert_eq!(statement(&b"import \"foo\" as foo;"[..]),
@ -524,11 +525,11 @@ mod test {
assert_eq!(statement(&b"let foo = 1.0 ;"[..]), assert_eq!(statement(&b"let foo = 1.0 ;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Let{name: "foo".to_string(), Statement::Let{name: "foo".to_string(),
value: Expression::Simple(Value::Float(1.0))})); value: Expression::Simple(Value::Float(make_value_node(1.0)))}));
assert_eq!(statement(&b"1.0;"[..]), assert_eq!(statement(&b"1.0;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::Float(1.0))))); Expression::Simple(Value::Float(make_value_node(1.0))))));
} }
#[test] #[test]
@ -562,15 +563,15 @@ mod test {
assert_eq!(let_statement(&b"let foo = 1.0 ;"[..]), assert_eq!(let_statement(&b"let foo = 1.0 ;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Let{name: "foo".to_string(), Statement::Let{name: "foo".to_string(),
value: Expression::Simple(Value::Float(1.0))})); value: Expression::Simple(Value::Float(make_value_node(1.0)))}));
assert_eq!(let_statement(&b"let foo= 1.0;"[..]), assert_eq!(let_statement(&b"let foo= 1.0;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Let{name: "foo".to_string(), Statement::Let{name: "foo".to_string(),
value: Expression::Simple(Value::Float(1.0))})); value: Expression::Simple(Value::Float(make_value_node(1.0)))}));
assert_eq!(let_statement(&b"let foo =1.0;"[..]), assert_eq!(let_statement(&b"let foo =1.0;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Let{name: "foo".to_string(), Statement::Let{name: "foo".to_string(),
value: Expression::Simple(Value::Float(1.0))})); value: Expression::Simple(Value::Float(make_value_node(1.0)))}));
} }
#[test] #[test]
@ -579,80 +580,80 @@ mod test {
assert_eq!(expression_statement(&b"1.0;"[..]), assert_eq!(expression_statement(&b"1.0;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::Float(1.0))))); Expression::Simple(Value::Float(make_value_node(1.0))))));
assert_eq!(expression_statement(&b"1.0 ;"[..]), assert_eq!(expression_statement(&b"1.0 ;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::Float(1.0))))); Expression::Simple(Value::Float(make_value_node(1.0))))));
assert_eq!(expression_statement(&b" 1.0;"[..]), assert_eq!(expression_statement(&b" 1.0;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::Float(1.0))))); Expression::Simple(Value::Float(make_value_node(1.0))))));
assert_eq!(expression_statement(&b"foo;"[..]), assert_eq!(expression_statement(&b"foo;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::Symbol("foo".to_string()))))); Expression::Simple(Value::Symbol(make_value_node("foo".to_string()))))));
assert_eq!(expression_statement(&b"foo ;"[..]), assert_eq!(expression_statement(&b"foo ;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::Symbol("foo".to_string()))))); Expression::Simple(Value::Symbol(make_value_node("foo".to_string()))))));
assert_eq!(expression_statement(&b" foo;"[..]), assert_eq!(expression_statement(&b" foo;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::Symbol("foo".to_string()))))); Expression::Simple(Value::Symbol(make_value_node("foo".to_string()))))));
assert_eq!(expression_statement(&b"\"foo\";"[..]), assert_eq!(expression_statement(&b"\"foo\";"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::String("foo".to_string()))))); Expression::Simple(Value::String(make_value_node("foo".to_string()))))));
assert_eq!(expression_statement(&b"\"foo\" ;"[..]), assert_eq!(expression_statement(&b"\"foo\" ;"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::String("foo".to_string()))))); Expression::Simple(Value::String(make_value_node("foo".to_string()))))));
assert_eq!(expression_statement(&b" \"foo\";"[..]), assert_eq!(expression_statement(&b" \"foo\";"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Statement::Expression( Statement::Expression(
Expression::Simple(Value::String("foo".to_string()))))); Expression::Simple(Value::String(make_value_node("foo".to_string()))))));
} }
#[test] #[test]
fn test_expression_parse() { fn test_expression_parse() {
assert_eq!(expression(&b"1"[..]), assert_eq!(expression(&b"1"[..]),
IResult::Done(&b""[..], Expression::Simple(Value::Int(1)))); IResult::Done(&b""[..], Expression::Simple(Value::Int(make_value_node(1)))));
assert_eq!(expression(&b"foo"[..]), assert_eq!(expression(&b"foo"[..]),
IResult::Done(&b""[..], Expression::Simple(Value::Symbol("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(1), Expression::Add(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))))); 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(1), Expression::Sub(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))))); 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(1), Expression::Mul(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))))); 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(1), Expression::Div(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))))); 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(1), Expression::Add(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))))); 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(1), Expression::Sub(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))))); 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(1), Expression::Mul(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))))); 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(1), Expression::Div(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))))); 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{
@ -661,7 +662,7 @@ mod test {
"arg2".to_string(), "arg2".to_string(),
], ],
fields: vec![ fields: vec![
("foo".to_string(), Expression::Simple(Value::Symbol("arg1".to_string()))), ("foo".to_string(), Expression::Simple(Value::Symbol(make_value_node("arg1".to_string())))),
], ],
}) })
) )
@ -669,10 +670,10 @@ mod test {
assert_eq!(expression(&b"select foo, 1, { foo = 2 };"[..]), assert_eq!(expression(&b"select foo, 1, { foo = 2 };"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Select(SelectDef{ Expression::Select(SelectDef{
val: Box::new(Expression::Simple(Value::Symbol("foo".to_string()))), val: Box::new(Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))),
default: Box::new(Expression::Simple(Value::Int(1))), default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
tuple: vec![ tuple: vec![
("foo".to_string(), Expression::Simple(Value::Int(2))) ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(2))))
] ]
}) })
) )
@ -682,8 +683,8 @@ mod test {
Expression::Call(CallDef{ Expression::Call(CallDef{
macroref: vec!["foo".to_string(),"bar".to_string()], macroref: vec!["foo".to_string(),"bar".to_string()],
arglist: vec![ arglist: vec![
Expression::Simple(Value::Int(1)), Expression::Simple(Value::Int(make_value_node(1))),
Expression::Simple(Value::String("foo".to_string())), Expression::Simple(Value::String(make_value_node("foo".to_string()))),
], ],
}) })
) )
@ -693,8 +694,8 @@ mod test {
Expression::Grouped( Expression::Grouped(
Box::new( Box::new(
Expression::Add( Expression::Add(
BinaryExpression(Value::Int(1), BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1)))) Box::new(Expression::Simple(Value::Int(make_value_node(1)))))
) )
) )
) )
@ -712,15 +713,15 @@ mod test {
assert_eq!(format_expression(&b"\"foo @ @\" % (1, 2)"[..]), assert_eq!(format_expression(&b"\"foo @ @\" % (1, 2)"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Format("foo @ @".to_string(), Expression::Format("foo @ @".to_string(),
vec![Expression::Simple(Value::Int(1)), vec![Expression::Simple(Value::Int(make_value_node(1))),
Expression::Simple(Value::Int(2))]) Expression::Simple(Value::Int(make_value_node(2)))])
) )
); );
assert_eq!(format_expression(&b"\"foo @ @\"%(1, 2)"[..]), assert_eq!(format_expression(&b"\"foo @ @\"%(1, 2)"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Format("foo @ @".to_string(), Expression::Format("foo @ @".to_string(),
vec![Expression::Simple(Value::Int(1)), vec![Expression::Simple(Value::Int(make_value_node(1))),
Expression::Simple(Value::Int(2))]) Expression::Simple(Value::Int(make_value_node(2)))])
) )
); );
} }
@ -738,8 +739,8 @@ mod test {
Expression::Call(CallDef{ Expression::Call(CallDef{
macroref: vec!["foo".to_string()], macroref: vec!["foo".to_string()],
arglist: vec![ arglist: vec![
Expression::Simple(Value::Int(1)), Expression::Simple(Value::Int(make_value_node(1))),
Expression::Simple(Value::String("foo".to_string())), Expression::Simple(Value::String(make_value_node("foo".to_string()))),
], ],
}) })
) )
@ -750,8 +751,8 @@ mod test {
Expression::Call(CallDef{ Expression::Call(CallDef{
macroref: vec!["foo".to_string(),"bar".to_string()], macroref: vec!["foo".to_string(),"bar".to_string()],
arglist: vec![ arglist: vec![
Expression::Simple(Value::Int(1)), Expression::Simple(Value::Int(make_value_node(1))),
Expression::Simple(Value::String("foo".to_string())), Expression::Simple(Value::String(make_value_node("foo".to_string()))),
], ],
}) })
) )
@ -768,10 +769,10 @@ mod test {
assert_eq!(select_expression(&b"select foo, 1, { foo = 2 };"[..]), assert_eq!(select_expression(&b"select foo, 1, { foo = 2 };"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Select(SelectDef{ Expression::Select(SelectDef{
val: Box::new(Expression::Simple(Value::Symbol("foo".to_string()))), val: Box::new(Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))),
default: Box::new(Expression::Simple(Value::Int(1))), default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))),
tuple: vec![ tuple: vec![
("foo".to_string(), Expression::Simple(Value::Int(2))) ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(2))))
] ]
}) })
) )
@ -797,8 +798,8 @@ mod test {
Expression::Macro(MacroDef{ Expression::Macro(MacroDef{
argdefs: vec!["arg1".to_string(), argdefs: vec!["arg1".to_string(),
"arg2".to_string()], "arg2".to_string()],
fields: vec![("foo".to_string(), Expression::Simple(Value::Int(1))), fields: vec![("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1)))),
("bar".to_string(), Expression::Simple(Value::Int(2))) ("bar".to_string(), Expression::Simple(Value::Int(make_value_node(2))))
] ]
}) })
) )
@ -811,8 +812,8 @@ mod test {
assert!(arglist(&b"arg1, arg2"[..]).is_done()); assert!(arglist(&b"arg1, arg2"[..]).is_done());
assert_eq!(arglist(&b"arg1, arg2"[..]), IResult::Done(&b""[..], assert_eq!(arglist(&b"arg1, arg2"[..]), IResult::Done(&b""[..],
vec![ vec![
Value::Symbol("arg1".to_string()), Value::Symbol(make_value_node("arg1".to_string())),
Value::Symbol("arg2".to_string()) Value::Symbol(make_value_node("arg2".to_string()))
])); ]));
} }
@ -830,7 +831,7 @@ mod test {
assert_eq!(copy_expression(&b"foo{bar=1}"[..]), assert_eq!(copy_expression(&b"foo{bar=1}"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Copy(vec!["foo".to_string()], Expression::Copy(vec!["foo".to_string()],
vec![("bar".to_string(), Expression::Simple(Value::Int(1)))]) vec![("bar".to_string(), Expression::Simple(Value::Int(make_value_node(1))))])
) )
); );
} }
@ -844,16 +845,16 @@ mod test {
Expression::Grouped( Expression::Grouped(
Box::new( Box::new(
Expression::Simple( Expression::Simple(
Value::Symbol("foo".to_string()))))) Value::Symbol(make_value_node("foo".to_string()))))))
); );
assert_eq!(grouped_expression(&b"(1 + 1)"[..]), assert_eq!(grouped_expression(&b"(1 + 1)"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Expression::Grouped( Expression::Grouped(
Box::new( Box::new(
Expression::Add( Expression::Add(
BinaryExpression(Value::Int(1), BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple( Box::new(Expression::Simple(
Value::Int(1)))) Value::Int(make_value_node(1)))))
) )
) )
) )
@ -873,29 +874,29 @@ mod test {
assert_eq!(tuple(&b"{ }"[..]), assert_eq!(tuple(&b"{ }"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Value::Tuple( Value::Tuple(
vec![]))); make_value_node(vec![]))));
assert_eq!(tuple(&b"{ foo = 1 }"[..]), assert_eq!(tuple(&b"{ foo = 1 }"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Value::Tuple( Value::Tuple(
vec![ make_value_node(vec![
("foo".to_string(), Expression::Simple(Value::Int(1))) ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1))))
]))); ]))));
assert_eq!(tuple(&b"{ foo = 1, bar = \"1\" }"[..]), assert_eq!(tuple(&b"{ foo = 1, bar = \"1\" }"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Value::Tuple( Value::Tuple(
vec![ make_value_node(vec![
("foo".to_string(), Expression::Simple(Value::Int(1))), ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1)))),
("bar".to_string(), Expression::Simple(Value::String("1".to_string()))) ("bar".to_string(), Expression::Simple(Value::String(make_value_node("1".to_string()))))
]))); ]))));
assert_eq!(tuple(&b"{ foo = 1, bar = {} }"[..]), assert_eq!(tuple(&b"{ foo = 1, bar = {} }"[..]),
IResult::Done(&b""[..], IResult::Done(&b""[..],
Value::Tuple( Value::Tuple(
vec![ make_value_node(vec![
("foo".to_string(), Expression::Simple(Value::Int(1))), ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1)))),
("bar".to_string(), Expression::Simple(Value::Tuple(Vec::new()))) ("bar".to_string(), Expression::Simple(Value::Tuple(make_value_node(Vec::new()))))
]))); ]))));
} }
#[test] #[test]
@ -904,13 +905,13 @@ mod test {
assert!(field_value(&b"foo ="[..]).is_incomplete() ); assert!(field_value(&b"foo ="[..]).is_incomplete() );
assert_eq!(field_value(&b"foo = 1"[..]), assert_eq!(field_value(&b"foo = 1"[..]),
IResult::Done(&b""[..], ("foo".to_string(), Expression::Simple(Value::Int(1)))) ); IResult::Done(&b""[..], ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1))))) );
assert_eq!(field_value(&b"foo = \"1\""[..]), assert_eq!(field_value(&b"foo = \"1\""[..]),
IResult::Done(&b""[..], ("foo".to_string(), Expression::Simple(Value::String("1".to_string())))) ); IResult::Done(&b""[..], ("foo".to_string(), Expression::Simple(Value::String(make_value_node("1".to_string()))))) );
assert_eq!(field_value(&b"foo = bar"[..]), assert_eq!(field_value(&b"foo = bar"[..]),
IResult::Done(&b""[..], ("foo".to_string(), Expression::Simple(Value::Symbol("bar".to_string())))) ); IResult::Done(&b""[..], ("foo".to_string(), Expression::Simple(Value::Symbol(make_value_node("bar".to_string()))))) );
assert_eq!(field_value(&b"foo = bar "[..]), assert_eq!(field_value(&b"foo = bar "[..]),
IResult::Done(&b""[..], ("foo".to_string(), Expression::Simple(Value::Symbol("bar".to_string())))) ); IResult::Done(&b""[..], ("foo".to_string(), Expression::Simple(Value::Symbol(make_value_node("bar".to_string()))))) );
} }
#[test] #[test]
@ -918,23 +919,23 @@ mod test {
assert!(number(&b"."[..]).is_err() ); assert!(number(&b"."[..]).is_err() );
assert!(number(&b". "[..]).is_err() ); assert!(number(&b". "[..]).is_err() );
assert_eq!(number(&b"1.0"[..]), assert_eq!(number(&b"1.0"[..]),
IResult::Done(&b""[..], Value::Float(1.0)) ); IResult::Done(&b""[..], Value::Float(make_value_node(1.0))) );
assert_eq!(number(&b"1."[..]), assert_eq!(number(&b"1."[..]),
IResult::Done(&b""[..], Value::Float(1.0)) ); IResult::Done(&b""[..], Value::Float(make_value_node(1.0))) );
assert_eq!(number(&b"1"[..]), assert_eq!(number(&b"1"[..]),
IResult::Done(&b""[..], Value::Int(1)) ); IResult::Done(&b""[..], Value::Int(make_value_node(1))) );
assert_eq!(number(&b".1"[..]), assert_eq!(number(&b".1"[..]),
IResult::Done(&b""[..], Value::Float(0.1)) ); IResult::Done(&b""[..], Value::Float(make_value_node(0.1))) );
} }
#[test] #[test]
fn test_symbol_parsing() { fn test_symbol_parsing() {
assert_eq!(symbol(&b"foo"[..]), assert_eq!(symbol(&b"foo"[..]),
IResult::Done(&b""[..], Value::Symbol("foo".to_string())) ); IResult::Done(&b""[..], Value::Symbol(make_value_node("foo".to_string()))) );
assert_eq!(symbol(&b"foo-bar"[..]), assert_eq!(symbol(&b"foo-bar"[..]),
IResult::Done(&b""[..], Value::Symbol("foo-bar".to_string())) ); IResult::Done(&b""[..], Value::Symbol(make_value_node("foo-bar".to_string()))) );
assert_eq!(symbol(&b"foo_bar"[..]), assert_eq!(symbol(&b"foo_bar"[..]),
IResult::Done(&b""[..], Value::Symbol("foo_bar".to_string())) ); IResult::Done(&b""[..], Value::Symbol(make_value_node("foo_bar".to_string()))) );
} }
#[test] #[test]
@ -959,11 +960,11 @@ mod test {
}, },
Statement::Let{ Statement::Let{
name: "foo".to_string(), name: "foo".to_string(),
value: Expression::Simple(Value::Int(1)) value: Expression::Simple(Value::Int(make_value_node(1)))
}, },
Statement::Expression( Statement::Expression(
Expression::Add(BinaryExpression(Value::Int(1), Expression::Add(BinaryExpression(Value::Int(make_value_node(1)),
Box::new(Expression::Simple(Value::Int(1))))) Box::new(Expression::Simple(Value::Int(make_value_node(1))))))
) )
]); ]);
} }