From b3677861c6b04d17805533632e51949019075b29 Mon Sep 17 00:00:00 2001 From: Jeremy Wall Date: Mon, 18 Sep 2017 20:12:34 -0500 Subject: [PATCH] Add datastructure to support tracking position of Value nodes in the AST. --- src/ast.rs | 84 +++++++++++++++------- src/build.rs | 134 +++++++++++++++++++---------------- src/parse.rs | 193 ++++++++++++++++++++++++++------------------------- 3 files changed, 231 insertions(+), 180 deletions(-) diff --git a/src/ast.rs b/src/ast.rs index d7c711c..64dae2c 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -14,20 +14,53 @@ use std::collections::HashSet; 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 SelectorList = Vec; // str is expected to always be a symbol. +#[derive(Debug,PartialEq,Clone)] +pub struct LocatedNode { + pub pos: Option, + pub val: T, +} + +impl LocatedNode { + 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(v: T) -> LocatedNode { + LocatedNode::new(v) +} + /// Value represents a Value in the UCG parsed AST. #[derive(Debug,PartialEq,Clone)] pub enum Value { // Constant Values - Int(i64), - Float(f64), - String(String), - Symbol(String), + Int(LocatedNode), + Float(LocatedNode), + String(LocatedNode), + Symbol(LocatedNode), // Complex Values - Tuple(FieldList), - Selector(SelectorList), + Tuple(LocatedNode), + Selector(LocatedNode), } impl Value { @@ -56,12 +89,12 @@ impl Value { pub fn to_string(&self) -> String { match self { - &Value::Int(ref i) => format!("{}", i), - &Value::Float(ref f) => format!("{}", f), - &Value::String(ref s) => format!("{}", s), - &Value::Symbol(ref s) => format!("{}", s), - &Value::Tuple(ref fs) => format!("{}", Self::fields_to_string(fs)), - &Value::Selector(ref v) => v.join("."), + &Value::Int(ref i) => format!("{}", i.val), + &Value::Float(ref f) => format!("{}", f.val), + &Value::String(ref s) => format!("{}", s.val), + &Value::Symbol(ref s) => format!("{}", s.val), + &Value::Tuple(ref fs) => format!("{}", Self::fields_to_string(&fs.val)), + &Value::Selector(ref v) => v.val.join("."), } } } @@ -99,12 +132,13 @@ impl MacroDef { if let &Value::Symbol(ref name) = val { let mut ok = true; for arg in self.argdefs.iter() { - ok &= arg == name + ok &= arg == &name.val } 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; if list.len() > 0 { // We only look to see if the first selector item exists. @@ -119,7 +153,8 @@ impl MacroDef { 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() { stack.push(expr); } @@ -257,8 +292,8 @@ mod ast_test { ], fields: vec![ ("f1".to_string(), Expression::Add(BinaryExpression( - Value::Symbol("foo".to_string()), - Box::new(Expression::Simple(Value::Int(1)))))), + Value::Symbol(make_value_node("foo".to_string())), + Box::new(Expression::Simple(Value::Int(make_value_node(1))))))), ], }; assert!(def.validate_symbols().unwrap() == ()); @@ -272,9 +307,10 @@ mod ast_test { ], fields: vec![ ("f1".to_string(), Expression::Add(BinaryExpression( - Value::Symbol("bar".to_string()), - Box::new(Expression::Simple(Value::Int(1)))))), + Value::Symbol(make_value_node("bar".to_string())), + Box::new(Expression::Simple(Value::Int(make_value_node(1))))))), ], + }; let mut expected = HashSet::new(); expected.insert("bar".to_string()); @@ -289,8 +325,8 @@ mod ast_test { ], fields: vec![ ("f1".to_string(), Expression::Add(BinaryExpression( - Value::Selector(vec!["foo".to_string(), "quux".to_string()]), - Box::new(Expression::Simple(Value::Int(1)))))), + Value::Selector(make_value_node(vec!["foo".to_string(), "quux".to_string()])), + Box::new(Expression::Simple(Value::Int(make_value_node(1))))))), ], }; assert!(def.validate_symbols().unwrap() == ()); @@ -304,8 +340,8 @@ mod ast_test { ], fields: vec![ ("f1".to_string(), Expression::Add(BinaryExpression( - Value::Selector(vec!["bar".to_string(), "quux".to_string()]), - Box::new(Expression::Simple(Value::Int(1)))))), + Value::Selector(make_value_node(vec!["bar".to_string(), "quux".to_string()])), + Box::new(Expression::Simple(Value::Int(make_value_node(1))))))), ], }; let mut expected = HashSet::new(); diff --git a/src/build.rs b/src/build.rs index 10c988b..d5dada0 100644 --- a/src/build.rs +++ b/src/build.rs @@ -220,14 +220,15 @@ impl Builder { /// new_builder constructs Builder with initialized fields ready to parse. fn value_to_val(&self, v: Value) -> Result, Box> { match v { - Value::Int(i) => Ok(Rc::new(Val::Int(i))), - Value::Float(f) => Ok(Rc::new(Val::Float(f))), - Value::String(s) => Ok(Rc::new(Val::String(s.to_string()))), + Value::Int(i) => Ok(Rc::new(Val::Int(i.val))), + Value::Float(f) => Ok(Rc::new(Val::Float(f.val))), + Value::String(s) => Ok(Rc::new(Val::String(s.val.to_string()))), Value::Symbol(s) => { - self.lookup_sym(&s).ok_or(Box::new( - BuildError::NoSuchSymbol(format!("Unable to find {}", s)))) + self.lookup_sym(&s.val).ok_or(Box::new( + 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(); for (name, expr) in fields.drain(0..) { let val = try!(self.eval_expr(expr)); @@ -236,8 +237,8 @@ impl Builder { new_fields.sort_by(|a, b| a.0.cmp(&b.0)); Ok(Rc::new(Val::Tuple(new_fields))) }, - Value::Selector(selector_list) => { - self.lookup_selector(selector_list) + Value::Selector(selector_list_node) => { + self.lookup_selector(selector_list_node.val) }, } } @@ -619,9 +620,11 @@ mod test { fn test_eval_div_expr() { let b = Builder::new(); 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)), - (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)), ], b); } @@ -631,7 +634,8 @@ mod test { fn test_eval_div_expr_fail() { let b = Builder::new(); 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)), ], b); } @@ -640,9 +644,11 @@ mod test { fn test_eval_mul_expr() { let b = Builder::new(); 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)), - (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)), ], b); } @@ -652,7 +658,8 @@ mod test { fn test_eval_mul_expr_fail() { let b = Builder::new(); 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)), ], b); } @@ -661,9 +668,11 @@ mod test { fn test_eval_subtract_expr() { let b = Builder::new(); 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)), - (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)), ], b); } @@ -673,7 +682,8 @@ mod test { fn test_eval_subtract_expr_fail() { let b = Builder::new(); 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)), ], b); } @@ -682,11 +692,14 @@ mod test { fn test_eval_add_expr() { let b = Builder::new(); 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)), - (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)), - (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())), ], b); } @@ -696,7 +709,8 @@ mod test { fn test_eval_add_expr_fail() { let b = Builder::new(); 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)), ], b); } @@ -704,12 +718,12 @@ mod test { #[test] fn test_eval_simple_expr() { test_expr_to_val(vec![ - (Expression::Simple(Value::Int(1)), Val::Int(1)), - (Expression::Simple(Value::Float(2.0)), Val::Float(2.0)), - (Expression::Simple(Value::String("foo".to_string())), + (Expression::Simple(Value::Int(make_value_node(1))), Val::Int(1)), + (Expression::Simple(Value::Float(make_value_node(2.0))), Val::Float(2.0)), + (Expression::Simple(Value::String(make_value_node("foo".to_string()))), Val::String("foo".to_string())), - (Expression::Simple(Value::Tuple(vec![("bar".to_string(), - Expression::Simple(Value::Int(1)))])), + (Expression::Simple(Value::Tuple(make_value_node(vec![("bar".to_string(), + Expression::Simple(Value::Int(make_value_node(1))))]))), Val::Tuple(vec![("bar".to_string(), Rc::new(Val::Int(1)))])), ], Builder::new()); } @@ -719,7 +733,7 @@ mod test { let mut b = Builder::new(); b.out.entry("var1".to_string()).or_insert(Rc::new(Val::Int(1))); 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); } @@ -727,7 +741,7 @@ mod test { fn test_eval_simple_lookup_error() { let mut b = Builder::new(); 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] @@ -746,7 +760,7 @@ mod test { ("lvl1".to_string(), Rc::new(Val::Int(4))) ]))); 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![ ("lvl1".to_string(), Rc::new(Val::Tuple( vec![ @@ -755,21 +769,21 @@ mod test { ))), ] )), - (Expression::Simple(Value::Selector(vec!["var1".to_string(), - "lvl1".to_string()])), + (Expression::Simple(Value::Selector(make_value_node(vec!["var1".to_string(), + "lvl1".to_string()]))), Val::Tuple( vec![ ("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(), - "lvl2".to_string()])), + "lvl2".to_string()]))), 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)), - (Expression::Simple(Value::Selector(vec!["var3".to_string(), - "lvl1".to_string()])), + (Expression::Simple(Value::Selector(make_value_node(vec!["var3".to_string(), + "lvl1".to_string()]))), Val::Int(4)), ], b); } @@ -805,7 +819,7 @@ mod test { test_expr_to_val(vec![ (Expression::Copy(vec!["tpl1".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( vec![ ("fld1".to_string(), Rc::new(Val::String("2".to_string()))), @@ -826,7 +840,7 @@ mod test { test_expr_to_val(vec![ (Expression::Copy(vec!["tpl1".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 Val::Tuple( // NOTE(jwall): The order of these is important in order to ensure @@ -841,9 +855,9 @@ mod test { (Expression::Copy(vec!["tpl1".to_string()], vec![ ("fld1".to_string(), - Expression::Simple(Value::Int(3))), + Expression::Simple(Value::Int(make_value_node(3)))), ("fld2".to_string(), - Expression::Simple(Value::String("2".to_string()))), + Expression::Simple(Value::String(make_value_node("2".to_string())))), ]), Val::Tuple( vec![ @@ -852,7 +866,7 @@ mod test { ], )), // 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( vec![ ("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{ argdefs: vec!["arg1".to_string()], 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![ (Expression::Call(CallDef{ 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![ ("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{ argdefs: vec!["arg2".to_string()], 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![ (Expression::Call(CallDef{ 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![ ("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()))); test_expr_to_val(vec![ (Expression::Select(SelectDef{ - val: Box::new(Expression::Simple(Value::Symbol("foo".to_string()))), - default: Box::new(Expression::Simple(Value::Int(1))), + val: Box::new(Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))), + default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))), tuple: vec![ - ("bar".to_string(), Expression::Simple(Value::Int(2))), - ("quux".to_string(), Expression::Simple(Value::String("2".to_string()))), + ("bar".to_string(), Expression::Simple(Value::Int(make_value_node(2)))), + ("quux".to_string(), Expression::Simple(Value::String(make_value_node("2".to_string())))), ], }), Val::Int(2)), (Expression::Select(SelectDef{ - val: Box::new(Expression::Simple(Value::Symbol("baz".to_string()))), - default: Box::new(Expression::Simple(Value::Int(1))), + val: Box::new(Expression::Simple(Value::Symbol(make_value_node("baz".to_string())))), + default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))), tuple: vec![ - ("bar".to_string(), Expression::Simple(Value::Int(2))), - ("quux".to_string(), Expression::Simple(Value::String("2".to_string()))), + ("bar".to_string(), Expression::Simple(Value::Int(make_value_node(2)))), + ("quux".to_string(), Expression::Simple(Value::String(make_value_node("2".to_string())))), ], }), // 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))); test_expr_to_val(vec![ (Expression::Select(SelectDef{ - val: Box::new(Expression::Simple(Value::Symbol("foo".to_string()))), - default: Box::new(Expression::Simple(Value::Int(1))), + val: Box::new(Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))), + default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))), tuple: vec![ - ("bar".to_string(), Expression::Simple(Value::Int(2))), - ("quux".to_string(), Expression::Simple(Value::String("2".to_string()))), + ("bar".to_string(), Expression::Simple(Value::Int(make_value_node(2)))), + ("quux".to_string(), Expression::Simple(Value::String(make_value_node("2".to_string())))), ], }), Val::Int(2)), @@ -954,10 +968,10 @@ mod test { let mut b = Builder::new(); b.build_stmt(Statement::Let{ name:"foo".to_string(), - value: Expression::Simple(Value::String("bar".to_string())), + value: Expression::Simple(Value::String(make_value_node("bar".to_string()))), }).unwrap(); 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())), ], b); } @@ -979,7 +993,7 @@ mod test { ]))), ]))); 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![ ("bar".to_string(), Rc::new(Val::Tuple(vec![ ("quux".to_string(), Rc::new(Val::Int(1))), diff --git a/src/parse.rs b/src/parse.rs index 73810e9..cb12a70 100644 --- a/src/parse.rs +++ b/src/parse.rs @@ -53,7 +53,6 @@ named!(fatcomma, tag!("=>")); fn is_symbol_char(c: u8) -> bool { is_alphanumeric(c) || c == '-' as u8 || c == '_' as u8 } - // a field is the building block of symbols and tuple field names. named!(field, map_res!(preceded!(peek!(alpha), take_while!(is_symbol_char)), @@ -62,7 +61,7 @@ named!(field, ); fn symbol_to_value(s: String) -> ParseResult { - Ok(Value::Symbol(s)) + Ok(Value::Symbol(make_value_node(s))) } // symbol is a bare unquoted field. @@ -76,7 +75,7 @@ named!(quoted, ); fn str_to_value(s: String) -> ParseResult { - Ok(Value::String(s)) + Ok(Value::String(make_value_node(s))) } // 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(); 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 { @@ -105,7 +104,7 @@ fn triple_to_number(v: (Option<&[u8]>, Option<&[u8]>, Option<&[u8]>)) let to_parse = pref.to_string() + "." + suf; 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 @@ -165,7 +164,7 @@ named!( // Helper function to make the return types work for down below. fn vec_to_tuple(v: FieldList) -> ParseResult { - Ok(Value::Tuple(v)) + Ok(Value::Tuple(make_value_node(v))) } named!(field_list, @@ -299,7 +298,7 @@ fn tuple_to_macro(mut t: (Vec, Value)) -> ParseResult { Value::Tuple(v) => { Ok(Expression::Macro(MacroDef { 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. @@ -333,7 +332,7 @@ fn tuple_to_select(t: (Expression, Expression, Value)) Ok(Expression::Select(SelectDef{ val: Box::new(t.0), default: Box::new(t.1), - tuple: v, + tuple: v.val, })) } // TODO(jwall): Show a better version of the unexpected parsed value. @@ -377,7 +376,7 @@ named!(format_expression, fn tuple_to_call(t: (Value, Vec)) -> ParseResult { if let Value::Selector(sl) = t.0 { Ok(Expression::Call(CallDef{ - macroref: sl, + macroref: sl.val, arglist: t.1, })) } else { @@ -386,7 +385,7 @@ fn tuple_to_call(t: (Value, Vec)) -> ParseResult { } fn vec_to_selector_value(v: SelectorList) -> ParseResult { - Ok(Value::Selector(v)) + Ok(Value::Selector(make_value_node(v))) } named!(selector_value, @@ -501,14 +500,16 @@ named!(pub parse >, many1!(ws!(statement))); #[cfg(test)] mod test { use std::str::from_utf8; + use super::{Statement, Expression, Value, MacroDef, SelectDef, CallDef}; use super::{number, symbol, parse, field_value, tuple, grouped_expression}; use super::{arglist, copy_expression, macro_expression, select_expression}; use super::{format_expression, call_expression, expression}; use super::{expression_statement, let_statement, import_statement, statement}; - use nom::IResult; use ast::*; + use nom::IResult; + #[test] fn test_statement_parse() { assert_eq!(statement(&b"import \"foo\" as foo;"[..]), @@ -524,11 +525,11 @@ mod test { assert_eq!(statement(&b"let foo = 1.0 ;"[..]), IResult::Done(&b""[..], 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;"[..]), IResult::Done(&b""[..], Statement::Expression( - Expression::Simple(Value::Float(1.0))))); + Expression::Simple(Value::Float(make_value_node(1.0)))))); } #[test] @@ -562,15 +563,15 @@ mod test { assert_eq!(let_statement(&b"let foo = 1.0 ;"[..]), IResult::Done(&b""[..], 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;"[..]), IResult::Done(&b""[..], 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;"[..]), IResult::Done(&b""[..], Statement::Let{name: "foo".to_string(), - value: Expression::Simple(Value::Float(1.0))})); + value: Expression::Simple(Value::Float(make_value_node(1.0)))})); } #[test] @@ -579,80 +580,80 @@ mod test { assert_eq!(expression_statement(&b"1.0;"[..]), IResult::Done(&b""[..], Statement::Expression( - Expression::Simple(Value::Float(1.0))))); + Expression::Simple(Value::Float(make_value_node(1.0)))))); assert_eq!(expression_statement(&b"1.0 ;"[..]), IResult::Done(&b""[..], Statement::Expression( - Expression::Simple(Value::Float(1.0))))); + Expression::Simple(Value::Float(make_value_node(1.0)))))); assert_eq!(expression_statement(&b" 1.0;"[..]), IResult::Done(&b""[..], Statement::Expression( - Expression::Simple(Value::Float(1.0))))); + Expression::Simple(Value::Float(make_value_node(1.0)))))); assert_eq!(expression_statement(&b"foo;"[..]), IResult::Done(&b""[..], 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 ;"[..]), IResult::Done(&b""[..], 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;"[..]), IResult::Done(&b""[..], 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\";"[..]), IResult::Done(&b""[..], 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\" ;"[..]), IResult::Done(&b""[..], 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\";"[..]), IResult::Done(&b""[..], Statement::Expression( - Expression::Simple(Value::String("foo".to_string()))))); + Expression::Simple(Value::String(make_value_node("foo".to_string())))))); } #[test] fn test_expression_parse() { 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"[..]), - 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"[..]), IResult::Done(&b""[..], - 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)))))))); assert_eq!(expression(&b"1 - 1"[..]), IResult::Done(&b""[..], - Expression::Sub(BinaryExpression(Value::Int(1), - Box::new(Expression::Simple(Value::Int(1))))))); + Expression::Sub(BinaryExpression(Value::Int(make_value_node(1)), + Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); assert_eq!(expression(&b"1 * 1"[..]), IResult::Done(&b""[..], - Expression::Mul(BinaryExpression(Value::Int(1), - Box::new(Expression::Simple(Value::Int(1))))))); + Expression::Mul(BinaryExpression(Value::Int(make_value_node(1)), + Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); assert_eq!(expression(&b"1 / 1"[..]), IResult::Done(&b""[..], - Expression::Div(BinaryExpression(Value::Int(1), - Box::new(Expression::Simple(Value::Int(1))))))); + Expression::Div(BinaryExpression(Value::Int(make_value_node(1)), + Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); assert_eq!(expression(&b"1+1"[..]), IResult::Done(&b""[..], - 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)))))))); assert_eq!(expression(&b"1-1"[..]), IResult::Done(&b""[..], - Expression::Sub(BinaryExpression(Value::Int(1), - Box::new(Expression::Simple(Value::Int(1))))))); + Expression::Sub(BinaryExpression(Value::Int(make_value_node(1)), + Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); assert_eq!(expression(&b"1*1"[..]), IResult::Done(&b""[..], - Expression::Mul(BinaryExpression(Value::Int(1), - Box::new(Expression::Simple(Value::Int(1))))))); + Expression::Mul(BinaryExpression(Value::Int(make_value_node(1)), + Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); assert_eq!(expression(&b"1/1"[..]), IResult::Done(&b""[..], - Expression::Div(BinaryExpression(Value::Int(1), - Box::new(Expression::Simple(Value::Int(1))))))); + Expression::Div(BinaryExpression(Value::Int(make_value_node(1)), + Box::new(Expression::Simple(Value::Int(make_value_node(1)))))))); assert_eq!(expression(&b"macro (arg1, arg2) => { foo = arg1 }"[..]), IResult::Done(&b""[..], Expression::Macro(MacroDef{ @@ -661,7 +662,7 @@ mod test { "arg2".to_string(), ], 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 };"[..]), IResult::Done(&b""[..], Expression::Select(SelectDef{ - val: Box::new(Expression::Simple(Value::Symbol("foo".to_string()))), - default: Box::new(Expression::Simple(Value::Int(1))), + val: Box::new(Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))), + default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))), 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{ macroref: vec!["foo".to_string(),"bar".to_string()], arglist: vec![ - Expression::Simple(Value::Int(1)), - Expression::Simple(Value::String("foo".to_string())), + Expression::Simple(Value::Int(make_value_node(1))), + Expression::Simple(Value::String(make_value_node("foo".to_string()))), ], }) ) @@ -693,8 +694,8 @@ mod test { Expression::Grouped( Box::new( Expression::Add( - BinaryExpression(Value::Int(1), - Box::new(Expression::Simple(Value::Int(1)))) + BinaryExpression(Value::Int(make_value_node(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)"[..]), IResult::Done(&b""[..], Expression::Format("foo @ @".to_string(), - vec![Expression::Simple(Value::Int(1)), - Expression::Simple(Value::Int(2))]) + vec![Expression::Simple(Value::Int(make_value_node(1))), + Expression::Simple(Value::Int(make_value_node(2)))]) ) ); assert_eq!(format_expression(&b"\"foo @ @\"%(1, 2)"[..]), IResult::Done(&b""[..], Expression::Format("foo @ @".to_string(), - vec![Expression::Simple(Value::Int(1)), - Expression::Simple(Value::Int(2))]) + vec![Expression::Simple(Value::Int(make_value_node(1))), + Expression::Simple(Value::Int(make_value_node(2)))]) ) ); } @@ -738,8 +739,8 @@ mod test { Expression::Call(CallDef{ macroref: vec!["foo".to_string()], arglist: vec![ - Expression::Simple(Value::Int(1)), - Expression::Simple(Value::String("foo".to_string())), + Expression::Simple(Value::Int(make_value_node(1))), + Expression::Simple(Value::String(make_value_node("foo".to_string()))), ], }) ) @@ -750,8 +751,8 @@ mod test { Expression::Call(CallDef{ macroref: vec!["foo".to_string(),"bar".to_string()], arglist: vec![ - Expression::Simple(Value::Int(1)), - Expression::Simple(Value::String("foo".to_string())), + Expression::Simple(Value::Int(make_value_node(1))), + 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 };"[..]), IResult::Done(&b""[..], Expression::Select(SelectDef{ - val: Box::new(Expression::Simple(Value::Symbol("foo".to_string()))), - default: Box::new(Expression::Simple(Value::Int(1))), + val: Box::new(Expression::Simple(Value::Symbol(make_value_node("foo".to_string())))), + default: Box::new(Expression::Simple(Value::Int(make_value_node(1)))), 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{ argdefs: vec!["arg1".to_string(), "arg2".to_string()], - fields: vec![("foo".to_string(), Expression::Simple(Value::Int(1))), - ("bar".to_string(), Expression::Simple(Value::Int(2))) + fields: vec![("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1)))), + ("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_eq!(arglist(&b"arg1, arg2"[..]), IResult::Done(&b""[..], vec![ - Value::Symbol("arg1".to_string()), - Value::Symbol("arg2".to_string()) + Value::Symbol(make_value_node("arg1".to_string())), + Value::Symbol(make_value_node("arg2".to_string())) ])); } @@ -830,7 +831,7 @@ mod test { assert_eq!(copy_expression(&b"foo{bar=1}"[..]), IResult::Done(&b""[..], 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( Box::new( Expression::Simple( - Value::Symbol("foo".to_string()))))) + Value::Symbol(make_value_node("foo".to_string())))))) ); assert_eq!(grouped_expression(&b"(1 + 1)"[..]), IResult::Done(&b""[..], Expression::Grouped( Box::new( Expression::Add( - BinaryExpression(Value::Int(1), + BinaryExpression(Value::Int(make_value_node(1)), Box::new(Expression::Simple( - Value::Int(1)))) + Value::Int(make_value_node(1))))) ) ) ) @@ -873,29 +874,29 @@ mod test { assert_eq!(tuple(&b"{ }"[..]), IResult::Done(&b""[..], Value::Tuple( - vec![]))); + make_value_node(vec![])))); assert_eq!(tuple(&b"{ foo = 1 }"[..]), IResult::Done(&b""[..], Value::Tuple( - vec![ - ("foo".to_string(), Expression::Simple(Value::Int(1))) - ]))); + make_value_node(vec![ + ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1)))) + ])))); assert_eq!(tuple(&b"{ foo = 1, bar = \"1\" }"[..]), IResult::Done(&b""[..], Value::Tuple( - vec![ - ("foo".to_string(), Expression::Simple(Value::Int(1))), - ("bar".to_string(), Expression::Simple(Value::String("1".to_string()))) - ]))); + make_value_node(vec![ + ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1)))), + ("bar".to_string(), Expression::Simple(Value::String(make_value_node("1".to_string())))) + ])))); assert_eq!(tuple(&b"{ foo = 1, bar = {} }"[..]), IResult::Done(&b""[..], Value::Tuple( - vec![ - ("foo".to_string(), Expression::Simple(Value::Int(1))), - ("bar".to_string(), Expression::Simple(Value::Tuple(Vec::new()))) - ]))); + make_value_node(vec![ + ("foo".to_string(), Expression::Simple(Value::Int(make_value_node(1)))), + ("bar".to_string(), Expression::Simple(Value::Tuple(make_value_node(Vec::new())))) + ])))); } #[test] @@ -904,13 +905,13 @@ mod test { assert!(field_value(&b"foo ="[..]).is_incomplete() ); 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\""[..]), - 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"[..]), - 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 "[..]), - 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] @@ -918,23 +919,23 @@ mod test { assert!(number(&b"."[..]).is_err() ); assert!(number(&b". "[..]).is_err() ); 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."[..]), - IResult::Done(&b""[..], Value::Float(1.0)) ); + IResult::Done(&b""[..], Value::Float(make_value_node(1.0))) ); 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"[..]), - IResult::Done(&b""[..], Value::Float(0.1)) ); + IResult::Done(&b""[..], Value::Float(make_value_node(0.1))) ); } #[test] fn test_symbol_parsing() { 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"[..]), - 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"[..]), - IResult::Done(&b""[..], Value::Symbol("foo_bar".to_string())) ); + IResult::Done(&b""[..], Value::Symbol(make_value_node("foo_bar".to_string()))) ); } #[test] @@ -959,11 +960,11 @@ mod test { }, Statement::Let{ name: "foo".to_string(), - value: Expression::Simple(Value::Int(1)) + value: Expression::Simple(Value::Int(make_value_node(1))) }, Statement::Expression( - 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)))))) ) ]); }