Moved conditionally_opt_whitespace to whitespace module.

Added `expr_keyword_opt_expr` parser.

Author: ngeor

rusty_parser/src/core/dim_name.rs

@@ -4,7 +4,9 @@ use rusty_pc::*;
 use crate::core::var_name;
 use crate::input::StringView;
 use crate::pc_specific::*;
-use crate::{ParserError, *};
+use crate::{
+    ArrayDimensions, BareName, BuiltInStyle, DimList, DimType, Name, ParserError, ToBareName, TypeQualifier, TypedName
+};
 
 pub type DimVar = TypedName<DimType>;
 pub type DimVarPos = Positioned<DimVar>;
@@ -122,10 +124,10 @@ where
 mod array_dimensions {
     use rusty_pc::*;
 
-    use crate::expr::{expression_pos_p, opt_second_expression_after_keyword};
+    use crate::expr::expr_keyword_opt_expr;
     use crate::input::StringView;
     use crate::pc_specific::*;
-    use crate::{ParserError, *};
+    use crate::{ArrayDimension, ArrayDimensions, Keyword, ParserError};
 
     pub fn array_dimensions_p()
     -> impl Parser<StringView, Output = ArrayDimensions, Error = ParserError> {
@@ -137,12 +139,7 @@ mod array_dimensions {
     // paren_expr ws* TO ws* paren_expr
     fn array_dimension_p() -> impl Parser<StringView, Output = ArrayDimension, Error = ParserError>
     {
-        opt_second_expression_after_keyword(
-            expression_pos_p(),
-            Keyword::To,
-            ExpressionTrait::is_parenthesis,
-        )
-        .map(|(l, opt_r)| match opt_r {
+        expr_keyword_opt_expr(Keyword::To).map(|(l, opt_r)| match opt_r {
             Some(r) => ArrayDimension {
                 lbound: Some(l),
                 ubound: r,
@@ -158,12 +155,12 @@ mod array_dimensions {
 mod type_definition {
     use rusty_pc::*;
 
-    use crate::core::VarNameCtx;
+    use crate::core::{VarNameCtx, user_defined_type};
     use crate::expr::expression_pos_p;
     use crate::input::StringView;
     use crate::pc_specific::*;
     use crate::tokens::star_ws;
-    use crate::{ParserError, *};
+    use crate::{BuiltInStyle, DimType, ExpressionPos, Keyword, ParserError, TypeQualifier};
 
     pub fn extended_type()
     -> impl Parser<StringView, VarNameCtx, Output = DimType, Error = ParserError> {

rusty_parser/src/core/select_case.rs

@@ -105,11 +105,11 @@ mod case_expression_parser {
     use rusty_common::Positioned;
     use rusty_pc::*;
 
-    use crate::expr::{expression_pos_p, opt_second_expression_after_keyword};
+    use crate::expr::{expr_keyword_opt_expr, expression_pos_p};
     use crate::input::StringView;
     use crate::pc_specific::*;
     use crate::tokens::{TokenType, any_token};
-    use crate::{CaseExpression, ExpressionTrait, Keyword, Operator, ParserError};
+    use crate::{CaseExpression, Keyword, Operator, ParserError};
 
     pub fn parser() -> impl Parser<StringView, Output = CaseExpression, Error = ParserError> {
         case_is().or(simple_or_range())
@@ -140,12 +140,7 @@ mod case_expression_parser {
     }
 
     fn simple_or_range() -> impl Parser<StringView, Output = CaseExpression, Error = ParserError> {
-        opt_second_expression_after_keyword(
-            expression_pos_p(),
-            Keyword::To,
-            ExpressionTrait::is_parenthesis,
-        )
-        .map(|(left, opt_right)| match opt_right {
+        expr_keyword_opt_expr(Keyword::To).map(|(left, opt_right)| match opt_right {
             Some(right) => CaseExpression::Range(left, right),
             _ => CaseExpression::Simple(left),
         })

rusty_parser/src/expr/opt_second_expression.rs

@@ -1,10 +1,10 @@
 use rusty_pc::and::TupleCombiner;
-use rusty_pc::{IifParser, Parser, ParserErrorTrait};
+use rusty_pc::{Parser, ParserErrorTrait};
 
 use crate::error::ParserError;
 use crate::expr::parsers::ws_expr_pos_p;
 use crate::input::StringView;
-use crate::pc_specific::{keyword, whitespace_ignoring};
+use crate::pc_specific::{conditionally_opt_whitespace, keyword};
 use crate::{ExpressionPos, Keyword};
 
 /// Parses an optional second expression that follows the first expression
@@ -55,24 +55,3 @@ fn ws_keyword(k: Keyword) -> impl Parser<StringView, bool, Error = ParserError>
 fn err(keyword: Keyword) -> ParserError {
     ParserError::expected(&format!("expression after {}", keyword)).to_fatal()
 }
-
-/// Creates a parser that parses whitespace,
-/// conditionally allowing it to be missing.
-/// When [allow_none] is false, whitespace is mandatory.
-/// When [allow_none] is true, the whitespace can be missing.
-/// This is typically the case when the previously parsed
-/// token was a right side parenthesis.
-///
-/// Examples
-///
-/// * `(1 + 2)AND` no whitespace is required before `AND`
-/// * `1 + 2AND` the lack of whitespace before `AND` is an error
-pub(super) fn conditionally_opt_whitespace()
--> impl Parser<StringView, bool, Output = (), Error = ParserError> {
-    IifParser::new(
-        // allow none
-        whitespace_ignoring().to_option().map_to_unit(),
-        // whitespace is required
-        whitespace_ignoring(),
-    )
-}

rusty_parser/src/expr/parsers.rs

@@ -1,7 +1,6 @@
-use rusty_pc::and::{KeepLeftCombiner, VecCombiner};
+use rusty_pc::and::{KeepLeftCombiner, TupleCombiner, VecCombiner};
 use rusty_pc::*;
 
-use crate::expr::opt_second_expression::conditionally_opt_whitespace;
 use crate::input::StringView;
 use crate::pc_specific::*;
 use crate::tokens::comma_ws;
@@ -136,3 +135,28 @@ pub fn expr_ws_followed_by(
         KeepLeftCombiner,
     )
 }
+
+/// Parses an expression, followed optionally by a keyword and a second expression.
+/// If the keyword is present, the second expression is mandatory.
+///
+/// Examples: `FOR I = 1 TO 100 [STEP 5]`, `CASE 1 [TO 2]`
+pub fn expr_keyword_opt_expr(
+    keyword: Keyword,
+) -> impl Parser<StringView, Output = (ExpressionPos, Option<ExpressionPos>), Error = ParserError> {
+    expression_pos_p().then_with_in_context(
+        opt_keyword_expr(keyword),
+        ExpressionTrait::is_parenthesis,
+        TupleCombiner,
+    )
+}
+
+/// Parses the optional `TO expr` part (e.g. `CASE 1 TO 2`)
+fn opt_keyword_expr(
+    keyword: Keyword,
+) -> impl Parser<StringView, bool, Output = Option<ExpressionPos>, Error = ParserError> {
+    let msg = format!("expression after {}", keyword);
+    conditionally_opt_whitespace()
+        .and_keep_right(keyword_ignoring(keyword).no_context())
+        .and_keep_right(ws_expr_pos_p().or_expected(&msg).no_context())
+        .to_option()
+}

rusty_parser/src/pc_specific/whitespace.rs

@@ -1,4 +1,4 @@
-use rusty_pc::{Parser, SurroundMode, surround};
+use rusty_pc::{IifParser, Parser, SurroundMode, surround};
 
 use crate::ParserError;
 use crate::input::StringView;
@@ -70,3 +70,24 @@ where
 {
     demand_ws().no_context().and_keep_right(parser)
 }
+
+/// Creates a parser that parses whitespace,
+/// conditionally allowing it to be missing.
+/// When [allow_none] is false, whitespace is mandatory.
+/// When [allow_none] is true, the whitespace can be missing.
+/// This is typically the case when the previously parsed
+/// token was a right side parenthesis.
+///
+/// Examples
+///
+/// * `(1 + 2)AND` no whitespace is required before `AND`
+/// * `1 + 2AND` the lack of whitespace before `AND` is an error
+pub fn conditionally_opt_whitespace()
+-> impl Parser<StringView, bool, Output = (), Error = ParserError> {
+    IifParser::new(
+        // allow none
+        opt_ws(),
+        // whitespace is required
+        whitespace_ignoring(),
+    )
+}