chore: Removed AllowNoneIf parser

Author: ngeor

rusty_parser/src/pc/allow_none_if.rs

@@ -1,6 +1,5 @@
 //! base module contains functionality that can be extracted into a library,
 //! it's generic and not specific to QBasic
-mod allow_none_if;
 mod and;
 mod and_without_undo;
 mod any;
@@ -30,7 +29,6 @@ pub mod supplier;
 mod to_option;
 mod tokenizers;
 
-pub use allow_none_if::*;
 pub use and::*;
 pub use and_without_undo::AndWithoutUndo;
 pub use any::*;

rusty_parser/src/pc/mod.rs

@@ -3,6 +3,7 @@ use rusty_variant::{MIN_INTEGER, MIN_LONG};
 
 use crate::lazy_parser;
 use crate::pc::*;
+use crate::specific::core::opt_second_expression::conditionally_opt_whitespace;
 use crate::specific::pc_specific::*;
 use crate::specific::{
     ExpressionType, FileHandle, HasExpressionType, Name, Operator, TypeQualifier, UnaryOperator,
@@ -544,7 +545,7 @@ fn followed_by_ws(
     parser.chain(
         |expr_pos| {
             let is_paren = expr_pos.is_parenthesis();
-            whitespace().allow_none_if(is_paren).no_incomplete()
+            conditionally_opt_whitespace(is_paren).no_incomplete()
         },
         |expr_pos, _| expr_pos,
     )

rusty_parser/src/specific/core/expression.rs

@@ -1,11 +1,13 @@
 use crate::error::ParseError;
-use crate::pc::{AllowNoneIf, And, AndWithoutUndo, Chain, Errors, Parser, RcStringView, ToOption};
+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, whitespace};
+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;
 }
@@ -16,15 +18,21 @@ impl ExtractExpression for ExpressionPos {
     }
 }
 
+/// 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>(
-    parser: P,
+    first_expression_parser: P,
     keyword: Keyword,
 ) -> impl Parser<RcStringView, Output = (P::Output, Option<ExpressionPos>)>
 where
     P: Parser<RcStringView>,
     P::Output: ExtractExpression,
 {
-    parser.chain(
+    first_expression_parser.chain(
         move |first| {
             let first_expr = first.to_expression();
             let is_paren = first_expr.is_parenthesis();
@@ -38,8 +46,7 @@ fn parse_second(
     k: Keyword,
     is_paren: bool,
 ) -> impl Parser<RcStringView, Output = Option<ExpressionPos>> {
-    whitespace()
-        .allow_none_if(is_paren)
+    conditionally_opt_whitespace(is_paren)
         .and_tuple(keyword(k))
         .and_without_undo_keep_right(ws_expr_pos_p().or_fail(err(k)))
         .to_option()
@@ -48,3 +55,24 @@ fn parse_second(
 fn err(keyword: Keyword) -> ParseError {
     ParseError::SyntaxError(format!("Expected: expression after {}", keyword))
 }
+
+/// 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(
+    allow_none: bool,
+) -> impl Parser<RcStringView, Output = Option<Token>> {
+    if allow_none {
+        boxed(opt_whitespace())
+    } else {
+        boxed(whitespace().map(Some))
+    }
+}

rusty_parser/src/specific/core/opt_second_expression.rs

@@ -81,7 +81,7 @@ pub fn whitespace() -> impl Parser<RcStringView, Output = Token> {
 }
 
 /// Optional whitespace.
-fn opt_whitespace() -> impl Parser<RcStringView, Output = Option<Token>> {
+pub fn opt_whitespace() -> impl Parser<RcStringView, Output = Option<Token>> {
     whitespace().to_option()
 }