chore: Removed obscure ExtractExpression trait

Removed obscure `ExtractExpression` trait in favor of a function.

Author: ngeor

rusty_parser/src/specific/core/dim_name.rs

@@ -137,17 +137,20 @@ mod array_dimensions {
     // expr ws+ TO ws+ expr (e.g. 1 TO 10)
     // paren_expr ws* TO ws* paren_expr
     fn array_dimension_p() -> impl Parser<RcStringView, Output = ArrayDimension> {
-        opt_second_expression_after_keyword(expression_pos_p(), Keyword::To).map(|(l, opt_r)| {
-            match opt_r {
-                Some(r) => ArrayDimension {
-                    lbound: Some(l),
-                    ubound: r,
-                },
-                None => ArrayDimension {
-                    lbound: None,
-                    ubound: l,
-                },
-            }
+        opt_second_expression_after_keyword(
+            expression_pos_p(),
+            Keyword::To,
+            ExpressionTrait::is_parenthesis,
+        )
+        .map(|(l, opt_r)| match opt_r {
+            Some(r) => ArrayDimension {
+                lbound: Some(l),
+                ubound: r,
+            },
+            None => ArrayDimension {
+                lbound: None,
+                ubound: l,
+            },
         })
     }
 }

rusty_parser/src/specific/core/for_loop.rs

@@ -4,7 +4,6 @@ use crate::specific::core::expression::expr_pos_ws_p;
 use crate::specific::core::expression::property;
 use crate::specific::core::expression::ws_expr_pos_p;
 use crate::specific::core::opt_second_expression::opt_second_expression_after_keyword;
-use crate::specific::core::opt_second_expression::ExtractExpression;
 use crate::specific::core::statements::ZeroOrMoreStatements;
 use crate::specific::pc_specific::*;
 use crate::specific::*;
@@ -42,14 +41,10 @@ fn parse_for_step_p() -> impl Parser<
         Option<ExpressionPos>,
     ),
 > {
-    opt_second_expression_after_keyword(parse_for_p(), Keyword::Step)
-        .map(|((n, l, u), opt_step)| (n, l, u, opt_step))
-}
-
-impl ExtractExpression for (ExpressionPos, ExpressionPos, ExpressionPos) {
-    fn to_expression(&self) -> &ExpressionPos {
-        &self.2
-    }
+    opt_second_expression_after_keyword(parse_for_p(), Keyword::Step, |(_var, _low, upper)| {
+        upper.is_parenthesis()
+    })
+    .map(|((n, l, u), opt_step)| (n, l, u, opt_step))
 }
 
 /// Parses the "FOR I = 1 TO 2" part

rusty_parser/src/specific/core/opt_second_expression.rs

@@ -3,39 +3,26 @@ use crate::pc::boxed::boxed;
 use crate::pc::{And, AndWithoutUndo, Chain, Errors, Map, Parser, RcStringView, ToOption, Token};
 use crate::specific::core::expression::ws_expr_pos_p;
 use crate::specific::pc_specific::{keyword, opt_whitespace, whitespace};
-use crate::specific::{ExpressionPos, ExpressionTrait, Keyword};
-
-/// Finds the rightmost expression of a given type,
-/// so that it can be determined if it ended in parenthesis or not.
-#[deprecated]
-pub trait ExtractExpression {
-    fn to_expression(&self) -> &ExpressionPos;
-}
-
-impl ExtractExpression for ExpressionPos {
-    fn to_expression(&self) -> &ExpressionPos {
-        self
-    }
-}
+use crate::specific::{ExpressionPos, Keyword};
 
 /// Parses an optional second expression that follows the first expression
 /// and a keyword.
 ///
 /// If the keyword is present, the second expression is mandatory.
 ///
 /// Example: `FOR I = 1 TO 100 [STEP 5]`
-pub fn opt_second_expression_after_keyword<P>(
-    first_expression_parser: P,
+pub fn opt_second_expression_after_keyword<P, F>(
+    first_parser: P,
     keyword: Keyword,
+    is_first_wrapped_in_parenthesis: F,
 ) -> impl Parser<RcStringView, Output = (P::Output, Option<ExpressionPos>)>
 where
     P: Parser<RcStringView>,
-    P::Output: ExtractExpression,
+    F: Fn(&P::Output) -> bool,
 {
-    first_expression_parser.chain(
+    first_parser.chain(
         move |first| {
-            let first_expr = first.to_expression();
-            let is_paren = first_expr.is_parenthesis();
+            let is_paren = is_first_wrapped_in_parenthesis(&first);
             parse_second(keyword, is_paren)
         },
         |first, opt_second| (first, opt_second),

rusty_parser/src/specific/core/select_case.rs

@@ -109,6 +109,7 @@ mod case_expression_parser {
     use crate::specific::core::opt_second_expression::opt_second_expression_after_keyword;
     use crate::specific::pc_specific::*;
     use crate::specific::{CaseExpression, Keyword, Operator};
+    use crate::ExpressionTrait;
     use rusty_common::Positioned;
 
     pub fn parser() -> impl Parser<RcStringView, Output = CaseExpression> {
@@ -141,12 +142,15 @@ mod case_expression_parser {
     }
 
     fn simple_or_range() -> impl Parser<RcStringView, Output = CaseExpression> {
-        opt_second_expression_after_keyword(expression_pos_p(), Keyword::To).map(
-            |(left, opt_right)| match opt_right {
-                Some(right) => CaseExpression::Range(left, right),
-                _ => CaseExpression::Simple(left),
-            },
+        opt_second_expression_after_keyword(
+            expression_pos_p(),
+            Keyword::To,
+            ExpressionTrait::is_parenthesis,
         )
+        .map(|(left, opt_right)| match opt_right {
+            Some(right) => CaseExpression::Range(left, right),
+            _ => CaseExpression::Simple(left),
+        })
     }
 }