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

DEV: remove some unneccessary error output.

Browse Source 
Working towards Issue #45
This commit is contained in:
Jeremy Wall 2019-05-28 20:53:13 -05:00
parent 07d132bebc
commit e5f406d4e9
3 changed files with 9 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/build/compile_test.rs
View File

@ -162,7 +162,6 @@ fn test_assert_just_keyword_compile_failures() {
Regex::new(r"line: 1, column: 1").unwrap(), Regex::new(r"line: 1, column: 1").unwrap(),
Regex::new(r"Expected Tuple \{ok=<bool>, desc=<str>\}: at <eval> line: 1, column: 8") Regex::new(r"Expected Tuple \{ok=<bool>, desc=<str>\}: at <eval> line: 1, column: 8")
.unwrap(), .unwrap(),
Regex::new(r"Expected Expression: at <eval> line: 1, column: 8").unwrap(),
], ],
); );
} }
@ -251,8 +250,6 @@ fn test_binary_operator_missing_operand_compile_failure() {
assert_build_failure( assert_build_failure(
"1 +", "1 +",
vec![ vec![
Regex::new(r"Abort while parsing operator expression: at <eval> line: 1, column: 1")
.unwrap(),
Regex::new(r"Missing operand for binary expression: at <eval> line: 1, column: 4") Regex::new(r"Missing operand for binary expression: at <eval> line: 1, column: 4")
.unwrap(), .unwrap(),
], ],
@ -385,7 +382,7 @@ fn test_incomplete_tuple_key_value_missing_value_compile_failure() {
assert_build_failure( assert_build_failure(
"{foo=", "{foo=",
vec![ vec![
Regex::new(r"Expected Expression").unwrap(), Regex::new(r"Not a Bareword").unwrap(),
Regex::new(r"at <eval> line: 1, column: 6").unwrap(), Regex::new(r"at <eval> line: 1, column: 6").unwrap(),
], ],
) )
@ -485,7 +482,7 @@ fn test_let_missing_expression_compile_failure() {
assert_build_failure( assert_build_failure(
"let foo =", "let foo =",
vec![ vec![
Regex::new(r"Expected Expression").unwrap(), Regex::new(r"Expected Expression to bind").unwrap(),
Regex::new(r"at <eval> line: 1, column: 10").unwrap(), Regex::new(r"at <eval> line: 1, column: 10").unwrap(),
], ],
) )

4
src/parse/mod.rs
View File

@ -775,7 +775,7 @@ fn expression(input: SliceIter<Token>) -> ParseResult<Expression> {
let _input = input.clone(); let _input = input.clone();
match trace_parse!(_input, op_expression) { match trace_parse!(_input, op_expression) {
Result::Incomplete(i) => Result::Incomplete(i), Result::Incomplete(i) => Result::Incomplete(i),
Result::Fail(_) => trace_parse!(input, wrap_err!(non_op_expression, "Expected Expression")), Result::Fail(_) => trace_parse!(input, non_op_expression),
Result::Abort(e) => Result::Abort(e), Result::Abort(e) => Result::Abort(e),
Result::Complete(rest, expr) => Result::Complete(rest, expr), Result::Complete(rest, expr) => Result::Complete(rest, expr),
} }
@ -799,7 +799,7 @@ make_fn!(
pos => pos, pos => pos,
name => wrap_err!(match_type!(BAREWORD), "Expected name for binding"), name => wrap_err!(match_type!(BAREWORD), "Expected name for binding"),
_ => punct!("="), _ => punct!("="),
val => wrap_err!(trace_parse!(expression), "Expected Expression"), val => trace_parse!(wrap_err!(expression, "Expected Expression to bind")),
_ => punct!(";"), _ => punct!(";"),
(Statement::Let(LetDef { (Statement::Let(LetDef {
pos: pos, pos: pos,

30
src/parse/precedence.rs
View File

@ -400,39 +400,19 @@ pub fn parse_precedence(i: SliceIter<Element>) -> Result<SliceIter<Element>, Exp
pub fn op_expression<'a>(i: SliceIter<'a, Token>) -> Result<SliceIter<Token>, Expression> { pub fn op_expression<'a>(i: SliceIter<'a, Token>) -> Result<SliceIter<Token>, Expression> {
let preparse = parse_operand_list(i.clone()); let preparse = parse_operand_list(i.clone());
match preparse { match preparse {
Result::Fail(e) => { Result::Fail(e) => Result::Fail(e),
let err = Error::caused_by( Result::Abort(e) => Result::Abort(e),
"Failed while parsing operator expression",
Box::new(e),
Box::new(i),
);
Result::Fail(err)
}
Result::Abort(e) => {
let err = Error::caused_by(
"Abort while parsing operator expression",
Box::new(e),
Box::new(i),
);
Result::Abort(err)
}
Result::Incomplete(i) => Result::Incomplete(i), Result::Incomplete(i) => Result::Incomplete(i),
Result::Complete(rest, oplist) => { Result::Complete(rest, oplist) => {
let i_ = SliceIter::new(&oplist); let i_ = SliceIter::new(&oplist);
let parse_result = parse_precedence(i_); let parse_result = parse_precedence(i_);
match parse_result { match parse_result {
Result::Fail(_e) => { Result::Fail(e) => {
let err = Error::new( let err = Error::new(e.get_msg(), Box::new(rest.clone()));
"Failed while parsing operator expression",
Box::new(rest.clone()),
);
Result::Fail(err) Result::Fail(err)
} }
Result::Abort(e) => { Result::Abort(e) => {
let err = Error::new( let err = Error::new(e.get_msg(), Box::new(rest.clone()));
format!("Abort while parsing operator expression\n{}", e),
Box::new(rest.clone()),
);
Result::Abort(err) Result::Abort(err)
} }
Result::Incomplete(_) => Result::Incomplete(i.clone()), Result::Incomplete(_) => Result::Incomplete(i.clone()),