refactor(pc): Merge SetContext trait into Parser

It helps with using hidden types (`impl Parser`).

Author: ngeor

rusty_parser/src/core/dim_name.rs

@@ -166,8 +166,7 @@ mod type_definition {
     use crate::{ParserError, *};
 
     pub fn extended_type()
-    -> impl Parser<StringView, VarNameCtx, Output = DimType, Error = ParserError>
-    + SetContext<VarNameCtx> {
+    -> impl Parser<StringView, VarNameCtx, Output = DimType, Error = ParserError> {
         ctx_parser::<StringView, VarNameCtx, ParserError>()
             .map(|(_opt_q, allow_user_defined)| {
                 let mut parsers: Vec<

rusty_parser/src/core/expression.rs

@@ -937,8 +937,7 @@ pub mod property {
     /// If it was qualified, we return Ok(None) without trying to parse,
     /// because qualified names can't have properties.
     fn ctx_dot_property()
-    -> impl Parser<StringView, bool, Output = Option<NameAsTokens>, Error = ParserError>
-    + SetContext<bool> {
+    -> impl Parser<StringView, bool, Output = Option<NameAsTokens>, Error = ParserError> {
         ctx_parser()
             .and_then(|was_first_expr_qualified| {
                 if was_first_expr_qualified {
@@ -1031,7 +1030,7 @@ mod binary_expression {
         bool,
         Output = Option<(Positioned<Operator>, ExpressionPos)>,
         Error = ParserError,
-    > + SetContext<bool> {
+    > {
         operator()
             .then_with_in_context(third_parser(), is_keyword_op, TupleCombiner)
             .to_option()
@@ -1041,8 +1040,7 @@ mod binary_expression {
         op.element == Operator::And || op.element == Operator::Or || op.element == Operator::Modulo
     }
 
-    fn third_parser()
-    -> impl Parser<StringView, bool, Output = ExpressionPos, Error = ParserError> + SetContext<bool>
+    fn third_parser() -> impl Parser<StringView, bool, Output = ExpressionPos, Error = ParserError>
     {
         IifParser::new(
             guard::parser().to_fatal(),
@@ -1077,8 +1075,7 @@ mod binary_expression {
     /// parenthesis. If that is the case, leading whitespace is not required for
     /// keyword based operators.
     fn operator()
-    -> impl Parser<StringView, bool, Output = Positioned<Operator>, Error = ParserError>
-    + SetContext<bool> {
+    -> impl Parser<StringView, bool, Output = Positioned<Operator>, Error = ParserError> {
         IifParser::new(
             // no whitespace needed
             opt_and_keep_right(whitespace_ignoring(), operator_p()),

rusty_parser/src/core/opt_second_expression.rs

@@ -1,5 +1,5 @@
 use rusty_pc::and::TupleCombiner;
-use rusty_pc::{IifParser, Parser, ParserErrorTrait, SetContext};
+use rusty_pc::{IifParser, Parser, ParserErrorTrait};
 
 use crate::core::expression::ws_expr_pos_p;
 use crate::error::ParserError;
@@ -33,8 +33,7 @@ where
 // first_parser AND [ cond_ws(is_first_paren) KEYWORD !AND! ws_expr ]
 fn parse_second(
     k: Keyword,
-) -> impl Parser<StringView, bool, Output = Option<ExpressionPos>, Error = ParserError> + SetContext<bool>
-{
+) -> impl Parser<StringView, bool, Output = Option<ExpressionPos>, Error = ParserError> {
     // the left side needs the context
     ws_keyword(k)
         .and_keep_right(
@@ -45,7 +44,7 @@ fn parse_second(
         .to_option()
 }
 
-fn ws_keyword(k: Keyword) -> impl Parser<StringView, bool, Error = ParserError> + SetContext<bool> {
+fn ws_keyword(k: Keyword) -> impl Parser<StringView, bool, Error = ParserError> {
     // the left side has the context
     conditionally_opt_whitespace().and_tuple(
         // but the right side does not
@@ -69,7 +68,7 @@ fn err(keyword: Keyword) -> ParserError {
 /// * `(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> + SetContext<bool> {
+-> impl Parser<StringView, bool, Output = (), Error = ParserError> {
     IifParser::new(
         // allow none
         whitespace_ignoring().to_option().map_to_unit(),

rusty_parser/src/core/param_name.rs

@@ -1,11 +1,13 @@
 use rusty_common::Positioned;
 use rusty_pc::*;
 
-use crate::core::{VarNameCtx, var_name};
+use crate::core::{VarNameCtx, user_defined_type, var_name};
 use crate::input::StringView;
 use crate::pc_specific::*;
 use crate::tokens::{any_symbol_of, any_token_of};
-use crate::{Keyword, ParserError, *};
+use crate::{
+    BareNamePos, BuiltInStyle, ExpressionType, HasExpressionType, Keyword, ParserError, TypeQualifier, TypedName, VarType
+};
 
 pub type Parameter = TypedName<ParamType>;
 pub type ParameterPos = Positioned<Parameter>;
@@ -94,9 +96,7 @@ fn array_indicator() -> impl Parser<StringView, Output = Option<(Token, Token)>,
     seq2(any_symbol_of!('('), any_symbol_of!(')'), |l, r| (l, r)).to_option()
 }
 
-fn extended_type()
--> impl Parser<StringView, VarNameCtx, Output = ParamType, Error = ParserError> + SetContext<VarNameCtx>
-{
+fn extended_type() -> impl Parser<StringView, VarNameCtx, Output = ParamType, Error = ParserError> {
     ctx_parser()
         .map(|(_, allow_user_defined)| {
             if allow_user_defined {

rusty_parser/src/core/print.rs

@@ -160,8 +160,7 @@ fn print_args_parser() -> impl Parser<StringView, Output = Vec<PrintArg>, Error
     )
 }
 
-fn print_arg_parser()
--> impl Parser<StringView, bool, Output = PrintArg, Error = ParserError> + SetContext<bool> {
+fn print_arg_parser() -> impl Parser<StringView, bool, Output = PrintArg, Error = ParserError> {
     IifParser::new(delimiter_print_arg(), any_print_arg())
 }
 

rusty_parser/src/core/statements.rs

@@ -42,7 +42,7 @@ pub fn zero_or_more_statements_p(
 fn one_statement_p(
     exit_keywords: &[Keyword],
     custom_err: Option<ParserError>,
-) -> impl Parser<StringView, bool, Output = StatementPos, Error = ParserError> + SetContext<bool> {
+) -> impl Parser<StringView, bool, Output = StatementPos, Error = ParserError> {
     one_statement_or_exit_keyword_p(exit_keywords, custom_err).and_then(
         |statement_or_exit_keyword| match statement_or_exit_keyword {
             // we parsed a statement, return it
@@ -60,8 +60,7 @@ fn one_statement_p(
 fn one_statement_or_exit_keyword_p(
     exit_keywords: &[Keyword],
     custom_err: Option<ParserError>,
-) -> impl Parser<StringView, bool, Output = StatementOrExitKeyword, Error = ParserError> + SetContext<bool>
-{
+) -> impl Parser<StringView, bool, Output = StatementOrExitKeyword, Error = ParserError> {
     ThenWithLeftParser::new(
         // must parse the separator
         ctx_demand_separator_p(),
@@ -86,8 +85,7 @@ fn is_comment(statement_or_exit_keyword: &StatementOrExitKeyword) -> bool {
 
 /// A statement separator that is aware if the previously parsed statement
 /// was a comment or not.
-fn ctx_demand_separator_p()
--> impl Parser<StringView, bool, Output = (), Error = ParserError> + SetContext<bool> {
+fn ctx_demand_separator_p() -> impl Parser<StringView, bool, Output = (), Error = ParserError> {
     // TODO consolidate the two separate separator functions, they are almost never used elsewhere
     IifParser::new(
         // last statement was comment

rusty_parser/src/core/var_name.rs

@@ -5,7 +5,9 @@ use crate::core::name::{bare_name_without_dots, name_p};
 use crate::input::StringView;
 use crate::pc_specific::*;
 use crate::tokens::whitespace_ignoring;
-use crate::{ParserError, *};
+use crate::{
+    ArrayDimensions, AsBareName, BareName, BareNamePos, DimType, ExpressionType, HasExpressionType, Keyword, Name, ParamType, ParserError, ToBareName, TypeQualifier
+};
 
 /// A variable name with a type.
 ///
@@ -118,9 +120,7 @@ where
     A: Fn() -> AP,
     AP: Parser<StringView, Error = ParserError> + 'static,
     B: Fn() -> BP + 'static,
-    BP: Parser<StringView, VarNameCtx, Output = T, Error = ParserError>
-        + SetContext<VarNameCtx>
-        + 'static,
+    BP: Parser<StringView, VarNameCtx, Output = T, Error = ParserError> + 'static,
 {
     name_with_opt_array(opt_array_parser_factory())
         .then_with_in_context(
@@ -133,18 +133,15 @@ where
 
 fn var_type_parser<T, BP>(
     extended_type_parser: BP,
-) -> impl Parser<StringView, VarNameCtx, Output = T, Error = ParserError> + SetContext<VarNameCtx>
+) -> impl Parser<StringView, VarNameCtx, Output = T, Error = ParserError>
 where
     T: Default + VarType,
-    BP: Parser<StringView, VarNameCtx, Output = T, Error = ParserError>
-        + SetContext<VarNameCtx>
-        + 'static,
+    BP: Parser<StringView, VarNameCtx, Output = T, Error = ParserError> + 'static,
 {
     qualified().or(extended(extended_type_parser)).or(bare())
 }
 
-fn qualified<T>()
--> impl Parser<StringView, VarNameCtx, Output = T, Error = ParserError> + SetContext<VarNameCtx>
+fn qualified<T>() -> impl Parser<StringView, VarNameCtx, Output = T, Error = ParserError>
 where
     T: Default + VarType,
 {
@@ -174,19 +171,18 @@ where
 
 fn extended<T, BP>(
     extended_type_parser: BP,
-) -> impl Parser<StringView, VarNameCtx, Output = T, Error = ParserError> + SetContext<VarNameCtx>
+) -> impl Parser<StringView, VarNameCtx, Output = T, Error = ParserError>
 where
     T: Default + VarType,
-    BP: Parser<StringView, VarNameCtx, Output = T, Error = ParserError> + SetContext<VarNameCtx>,
+    BP: Parser<StringView, VarNameCtx, Output = T, Error = ParserError>,
 {
     let extended_type_parser = extended_type_parser.to_fatal();
     as_clause()
         .no_context()
         .and_keep_right(extended_type_parser)
 }
 
-fn bare<T>()
--> impl Parser<StringView, VarNameCtx, Output = T, Error = ParserError> + SetContext<VarNameCtx>
+fn bare<T>() -> impl Parser<StringView, VarNameCtx, Output = T, Error = ParserError>
 where
     T: Default + VarType,
 {

rusty_parser/src/pc_specific/keyword.rs

@@ -107,12 +107,7 @@ where
             Err(err) => Err(err),
         }
     }
-}
 
-impl<C, P> SetContext<C> for KeywordParser<P>
-where
-    P: SetContext<C>,
-{
     fn set_context(&mut self, ctx: C) {
         self.parser.set_context(ctx);
     }

rusty_parser/src/pc_specific/logging.rs

@@ -1,5 +1,5 @@
 #[cfg(debug_assertions)]
-use rusty_pc::{Parser, SetContext};
+use rusty_pc::Parser;
 
 use crate::error::ParserError;
 use crate::input::StringView;
@@ -89,13 +89,8 @@ where
             }
         }
     }
-}
 
-impl<P> SetContext<()> for LoggingParser<P>
-where
-    P: SetContext<()>,
-{
-    fn set_context(&mut self, _ctx: ()) {
-        self.parser.set_context(_ctx);
+    fn set_context(&mut self, ctx: ()) {
+        self.parser.set_context(ctx);
     }
 }

rusty_parser/src/pc_specific/with_pos.rs

@@ -1,5 +1,5 @@
 use rusty_common::{AtPos, HasPos, Positioned};
-use rusty_pc::{InputTrait, Parser, SetContext};
+use rusty_pc::{InputTrait, Parser};
 
 pub trait WithPos<I, C>: Parser<I, C>
 where
@@ -38,12 +38,7 @@ where
         let pos = tokenizer.pos();
         self.parser.parse(tokenizer).map(|x| x.at_pos(pos))
     }
-}
 
-impl<C, P> SetContext<C> for WithPosMapper<P>
-where
-    P: SetContext<C>,
-{
     fn set_context(&mut self, ctx: C) {
         self.parser.set_context(ctx)
     }