Removed guard parser

Author: ngeor

rusty_parser/src/expr/binary_expression.rs

@@ -3,7 +3,7 @@ use rusty_pc::and::TupleCombiner;
 use rusty_pc::*;
 
 use crate::error::ParserError;
-use crate::expr::expression_pos_p;
+use crate::expr::{expression_pos_p, ws_expr_pos_p};
 use crate::input::StringView;
 use crate::pc_specific::{OrExpected, WithPos, lead_opt_ws, lead_ws};
 use crate::tokens::{TokenType, any_token};
@@ -31,28 +31,29 @@ fn second_parser() -> impl Parser<
     Error = ParserError,
 > {
     operator()
-        .then_with_in_context(third_parser(), is_keyword_op, TupleCombiner)
+        .then_with_in_context(expr_after_binary_operator(), is_keyword_op, TupleCombiner)
         .to_option()
 }
 
 fn is_keyword_op(op: &Positioned<Operator>) -> bool {
     op.element == Operator::And || op.element == Operator::Or || op.element == Operator::Modulo
 }
 
-fn third_parser() -> impl Parser<StringView, bool, Output = ExpressionPos, Error = ParserError> {
+fn expr_after_binary_operator()
+-> impl Parser<StringView, bool, Output = ExpressionPos, Error = ParserError> {
+    // boxed breaks apart the recursive type evaluation
     IifParser::new(
-        super::guard::parser().to_fatal(),
-        super::guard::parser().to_option().map_to_unit(),
+        // the previous operator is a keyword op, must have whitespace or parenthesis
+        ws_expr_pos_p()
+            .boxed()
+            .or_expected("expression after operator"),
+        // the previous operator is a symbol, whitespace is optional
+        lead_opt_ws(
+            expression_pos_p()
+                .boxed()
+                .or_expected("expression after operator"),
+        ),
     )
-    .and_keep_right(right_side_expr().no_context())
-}
-
-/// Parses the right side expression, after having parsed the binary operator
-fn right_side_expr() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
-    // boxed breaks apart the recursive type evaluation
-    expression_pos_p()
-        .or_expected("expression after operator")
-        .boxed()
 }
 
 fn non_bin_expr() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {

rusty_parser/src/expr/guard.rs

@@ -2,7 +2,6 @@ mod binary_expression;
 mod built_in_function_call;
 pub mod file_handle;
 mod function_call_or_array_element;
-mod guard;
 mod integer_or_long_literal;
 mod opt_second_expression;
 mod parenthesis;

rusty_parser/src/expr/mod.rs

@@ -49,9 +49,7 @@ pub fn expression_pos_p() -> impl Parser<StringView, Output = ExpressionPos, Err
 /// <expr-in-parenthesis>
 /// ```
 pub fn ws_expr_pos_p() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
-    // ws* ( expr )
-    // ws+ expr
-    preceded_by_ws(expression_pos_p())
+    super::parenthesis::parser().or(lead_ws(expression_pos_p()))
 }
 
 /// Parses an expression that is either followed by whitespace
@@ -84,12 +82,6 @@ pub fn ws_expr_pos_ws_p() -> impl Parser<StringView, Output = ExpressionPos, Err
     followed_by_ws(ws_expr_pos_p())
 }
 
-fn preceded_by_ws(
-    parser: impl Parser<StringView, Output = ExpressionPos, Error = ParserError>,
-) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
-    super::guard::parser().and_keep_right(parser)
-}
-
 fn followed_by_ws(
     parser: impl Parser<StringView, Output = ExpressionPos, Error = ParserError>,
 ) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {

rusty_parser/src/expr/parsers.rs

@@ -1,27 +1,34 @@
 use rusty_common::Positioned;
 use rusty_pc::*;
 
-use crate::expr::{expression_pos_p, guard};
+use crate::expr::{expression_pos_p, ws_expr_pos_p};
 use crate::input::StringView;
 use crate::pc_specific::{OrExpected, WithPos, keyword};
 use crate::tokens::minus_sign;
 use crate::{ExpressionPos, ExpressionPosTrait, Keyword, ParserError, UnaryOperator};
 
 pub(super) fn parser() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
-    seq2(
-        unary_op(),
-        expression_pos_p().or_expected("expression after unary operator"),
-        |Positioned { element: op, pos }, expr| expr.apply_unary_priority_order(op, pos),
-    )
+    unary_minus()
+        .or(unary_not())
+        .map(|(Positioned { element: op, pos }, expr)| expr.apply_unary_priority_order(op, pos))
 }
 
-fn unary_op() -> impl Parser<StringView, Output = Positioned<UnaryOperator>, Error = ParserError> {
+fn unary_minus()
+-> impl Parser<StringView, Output = (Positioned<UnaryOperator>, ExpressionPos), Error = ParserError>
+{
     minus_sign()
         .map(|_| UnaryOperator::Minus)
-        .or(keyword(Keyword::Not)
-            .and_keep_right(guard::parser().to_fatal())
-            .map(|_| UnaryOperator::Not))
         .with_pos()
+        .and_tuple(expression_pos_p().or_expected("expression after -"))
+}
+
+fn unary_not()
+-> impl Parser<StringView, Output = (Positioned<UnaryOperator>, ExpressionPos), Error = ParserError>
+{
+    keyword(Keyword::Not)
+        .map(|_| UnaryOperator::Not)
+        .with_pos()
+        .and_tuple(ws_expr_pos_p().or_expected("expression after NOT"))
 }
 
 #[cfg(test)]