From e5f406d4e974c0422ec67bf2887f9f4934a73ed4 Mon Sep 17 00:00:00 2001
From: Jeremy Wall <jeremy@marzhillstudios.com>
Date: Tue, 28 May 2019 20:53:13 -0500
Subject: [PATCH] DEV: remove some unneccessary error output.

Working towards Issue #45
---
 src/build/compile_test.rs |  7 ++-----
 src/parse/mod.rs          |  4 ++--
 src/parse/precedence.rs   | 30 +++++-------------------------
 3 files changed, 9 insertions(+), 32 deletions(-)

diff --git a/src/build/compile_test.rs b/src/build/compile_test.rs
index 31313e6..d761303 100644
--- a/src/build/compile_test.rs
+++ b/src/build/compile_test.rs
@@ -162,7 +162,6 @@ fn test_assert_just_keyword_compile_failures() {
             Regex::new(r"line: 1, column: 1").unwrap(),
             Regex::new(r"Expected Tuple \{ok=<bool>, desc=<str>\}: at <eval> line: 1, column: 8")
                 .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(
         "1 +",
         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")
                 .unwrap(),
         ],
@@ -385,7 +382,7 @@ fn test_incomplete_tuple_key_value_missing_value_compile_failure() {
     assert_build_failure(
         "{foo=",
         vec![
-            Regex::new(r"Expected Expression").unwrap(),
+            Regex::new(r"Not a Bareword").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(
         "let foo =",
         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(),
         ],
     )
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index e436c19..8a7e649 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -775,7 +775,7 @@ fn expression(input: SliceIter<Token>) -> ParseResult<Expression> {
     let _input = input.clone();
     match trace_parse!(_input, op_expression) {
         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::Complete(rest, expr) => Result::Complete(rest, expr),
     }
@@ -799,7 +799,7 @@ make_fn!(
         pos => pos,
         name => wrap_err!(match_type!(BAREWORD), "Expected name for binding"),
         _ => punct!("="),
-        val => wrap_err!(trace_parse!(expression), "Expected Expression"),
+        val => trace_parse!(wrap_err!(expression, "Expected Expression to bind")),
         _ => punct!(";"),
         (Statement::Let(LetDef {
             pos: pos,
diff --git a/src/parse/precedence.rs b/src/parse/precedence.rs
index cd217a1..f84474e 100644
--- a/src/parse/precedence.rs
+++ b/src/parse/precedence.rs
@@ -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> {
     let preparse = parse_operand_list(i.clone());
     match preparse {
-        Result::Fail(e) => {
-            let err = Error::caused_by(
-                "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::Fail(e) => Result::Fail(e),
+        Result::Abort(e) => Result::Abort(e),
         Result::Incomplete(i) => Result::Incomplete(i),
         Result::Complete(rest, oplist) => {
             let i_ = SliceIter::new(&oplist);
             let parse_result = parse_precedence(i_);
             match parse_result {
-                Result::Fail(_e) => {
-                    let err = Error::new(
-                        "Failed while parsing operator expression",
-                        Box::new(rest.clone()),
-                    );
+                Result::Fail(e) => {
+                    let err = Error::new(e.get_msg(), Box::new(rest.clone()));
                     Result::Fail(err)
                 }
                 Result::Abort(e) => {
-                    let err = Error::new(
-                        format!("Abort while parsing operator expression\n{}", e),
-                        Box::new(rest.clone()),
-                    );
+                    let err = Error::new(e.get_msg(), Box::new(rest.clone()));
                     Result::Abort(err)
                 }
                 Result::Incomplete(_) => Result::Incomplete(i.clone()),