refactor(pc): Pass context by reference

ngeor · ngeor · commit 4166643d65a5 · 2026-02-15T15:43:06.000+01:00
Propagate context by reference in `set_context`. This removes the need for cloning e.g. in `AndParser`.

Added `MapCtxParser` to transform the context into a different type.

Removed the projection function from `ThenWithParser` (migrated to using `MapCtxParser`).
diff --git a/rusty_parser/src/core/for_loop.rs b/rusty_parser/src/core/for_loop.rs
@@ -43,8 +43,7 @@ fn parse_for_step_p() -> impl Parser<
     Error = ParserError,
 > {
     parse_for_p().then_with_in_context(
-        opt_step_p(),
-        |(_, _, upper)| upper.is_parenthesis(),
+        opt_step_p().map_ctx(|(_, _, upper): &(_, _, ExpressionPos)| upper.is_parenthesis()),
         |(n, l, u), opt_step| (n, l, u, opt_step),
     )
 }
diff --git a/rusty_parser/src/core/sub_call.rs b/rusty_parser/src/core/sub_call.rs
@@ -47,7 +47,6 @@ pub fn sub_call_or_assignment_p() -> impl Parser<StringView, Output = Statement,
                 }
             })
             .flatten(),
-        |x| x.clone(),
         KeepRightCombiner,
     )
 }
diff --git a/rusty_parser/src/core/var_name.rs b/rusty_parser/src/core/var_name.rs
@@ -123,8 +123,9 @@ where
 {
     name_with_opt_array(opt_array_parser_factory())
         .then_with_in_context(
-            var_type_parser(extended_type_parser_factory()),
-            |(name, _array)| (name.qualifier(), !name.as_bare_name().contains('.')),
+            var_type_parser(extended_type_parser_factory()).map_ctx(
+                |(name, _array): &(Name, _)| (name.qualifier(), !name.as_bare_name().contains('.')),
+            ),
             TupleCombiner,
         )
         .map(|((name, array), var_type)| create_typed_name(name, array, var_type))
diff --git a/rusty_parser/src/expr/binary_expression.rs b/rusty_parser/src/expr/binary_expression.rs
@@ -13,8 +13,7 @@ use crate::{ExpressionPos, ExpressionPosTrait, ExpressionTrait, Keyword, Operato
 pub(super) fn parser() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
     non_bin_expr()
         .then_with_in_context(
-            second_parser(),
-            |first| first.is_parenthesis(),
+            second_parser().map_ctx(ExpressionTrait::is_parenthesis),
             TupleCombiner,
         )
         .map(|(l, r)| match r {
@@ -31,7 +30,10 @@ fn second_parser() -> impl Parser<
     Error = ParserError,
 > {
     operator()
-        .then_with_in_context(expr_after_binary_operator(), is_keyword_op, TupleCombiner)
+        .then_with_in_context(
+            expr_after_binary_operator().map_ctx(is_keyword_op),
+            TupleCombiner,
+        )
         .to_option()
 }
 
diff --git a/rusty_parser/src/expr/parsers.rs b/rusty_parser/src/expr/parsers.rs
@@ -70,8 +70,7 @@ fn followed_by_ws(
     parser: impl Parser<StringView, Output = ExpressionPos, Error = ParserError>,
 ) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
     parser.then_with_in_context(
-        conditionally_opt_whitespace(),
-        |e| e.is_parenthesis(),
+        conditionally_opt_whitespace().map_ctx(ExpressionTrait::is_parenthesis),
         KeepLeftCombiner,
     )
 }
@@ -124,8 +123,8 @@ pub fn expr_ws_followed_by(
     expr_parser.then_with_in_context(
         conditionally_opt_whitespace()
             .to_fatal()
-            .and_keep_right(other_parser.to_fatal().no_context()),
-        |e| e.is_parenthesis(),
+            .and_keep_right(other_parser.to_fatal().no_context())
+            .map_ctx(ExpressionTrait::is_parenthesis),
         KeepLeftCombiner,
     )
 }
@@ -138,8 +137,7 @@ 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,
+        opt_keyword_expr(keyword).map_ctx(ExpressionTrait::is_parenthesis),
         TupleCombiner,
     )
 }
diff --git a/rusty_parser/src/expr/property.rs b/rusty_parser/src/expr/property.rs
@@ -17,8 +17,8 @@ use crate::{BareName, Expression, ExpressionPos, ExpressionType, Name, NameAsTok
 pub fn parser() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
     base_expr_pos_p()
         .then_with_in_context(
-            ctx_dot_property(),
-            |first_expr_pos| is_qualified(&first_expr_pos.element),
+            ctx_dot_property()
+                .map_ctx(|first_expr_pos: &ExpressionPos| is_qualified(&first_expr_pos.element)),
             TupleCombiner,
         )
         .and_then(|(first_expr_pos, properties)| {
diff --git a/rusty_parser/src/pc_specific/keyword.rs b/rusty_parser/src/pc_specific/keyword.rs
@@ -108,7 +108,7 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx);
     }
 }
diff --git a/rusty_parser/src/pc_specific/logging.rs b/rusty_parser/src/pc_specific/logging.rs
@@ -90,7 +90,7 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: ()) {
+    fn set_context(&mut self, ctx: &()) {
         self.parser.set_context(ctx);
     }
 }
diff --git a/rusty_parser/src/pc_specific/with_pos.rs b/rusty_parser/src/pc_specific/with_pos.rs
@@ -39,7 +39,7 @@ where
         self.parser.parse(tokenizer).map(|x| x.at_pos(pos))
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_parser/src/tokens/any_token_of.rs b/rusty_parser/src/tokens/any_token_of.rs
@@ -196,7 +196,7 @@ where
         self.parse_token(input)
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/and.rs b/rusty_pc/src/and.rs
@@ -24,7 +24,6 @@ impl<L, R, F, O> AndParser<L, R, F, O> {
 impl<I, C, L, R, F, O> Parser<I, C> for AndParser<L, R, F, O>
 where
     I: InputTrait,
-    C: Clone,
     L: Parser<I, C>,
     R: Parser<I, C, Error = L::Error>,
     F: Combiner<L::Output, R::Output, O>,
@@ -46,8 +45,8 @@ where
         }
     }
 
-    fn set_context(&mut self, context: C) {
-        self.left.set_context(context.clone());
+    fn set_context(&mut self, context: &C) {
+        self.left.set_context(context);
         self.right.set_context(context);
     }
 }
diff --git a/rusty_pc/src/and_then.rs b/rusty_pc/src/and_then.rs
@@ -23,7 +23,7 @@ where
         self.parser.parse(tokenizer).and_then(&self.mapper)
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/and_then_err.rs b/rusty_pc/src/and_then_err.rs
@@ -27,7 +27,7 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/boxed.rs b/rusty_pc/src/boxed.rs
@@ -28,7 +28,7 @@ where
         self.parser.parse(input)
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/ctx.rs b/rusty_pc/src/ctx.rs
@@ -36,12 +36,12 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         // This is the actual point where the context gets stored.
         // All other parser combinators are supposed to propagate
         // it with the `in_context` method, recreating themselves
         // and invoking `in_context` on the parsers they decorate.
-        self.0 = Some(ctx);
+        self.0 = Some(ctx.clone());
     }
 }
 
@@ -70,7 +70,7 @@ where
         self.parser.parse(input)
     }
 
-    fn set_context(&mut self, _ctx: C2) {}
+    fn set_context(&mut self, _ctx: &C2) {}
 }
 
 /// Based on the boolean context, parses using the left or the right parser.
@@ -107,7 +107,7 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: bool) {
-        self.context = ctx;
+    fn set_context(&mut self, ctx: &bool) {
+        self.context = *ctx;
     }
 }
diff --git a/rusty_pc/src/delimited.rs b/rusty_pc/src/delimited.rs
@@ -88,7 +88,6 @@ impl<E> ElementCollector<E> for OptionalElementCollector {
 impl<I, C, P, D, E, A> Parser<I, C> for DelimitedParser<P, D, E, A>
 where
     I: InputTrait,
-    C: Clone,
     P: Parser<I, C, Error = E>,
     D: Parser<I, C, Error = E>,
     E: ParserErrorTrait,
@@ -161,8 +160,8 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: C) {
-        self.parser.set_context(ctx.clone());
+    fn set_context(&mut self, ctx: &C) {
+        self.parser.set_context(ctx);
         self.delimiter.set_context(ctx);
     }
 }
diff --git a/rusty_pc/src/filter.rs b/rusty_pc/src/filter.rs
@@ -31,7 +31,7 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/filter_map.rs b/rusty_pc/src/filter_map.rs
@@ -31,7 +31,7 @@ where
             })
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/flatten.rs b/rusty_pc/src/flatten.rs
@@ -31,7 +31,7 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: COut) {
+    fn set_context(&mut self, ctx: &COut) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/init_context.rs b/rusty_pc/src/init_context.rs
@@ -20,14 +20,13 @@ impl<I, COuter, CInner, P> Parser<I, COuter> for InitContextParser<P, CInner>
 where
     I: InputTrait,
     P: Parser<I, CInner>,
-    CInner: Clone,
 {
     type Output = P::Output;
     type Error = P::Error;
     fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
-        self.parser.set_context(self.value.clone());
+        self.parser.set_context(&self.value);
         self.parser.parse(input)
     }
 
-    fn set_context(&mut self, _ctx: COuter) {}
+    fn set_context(&mut self, _ctx: &COuter) {}
 }
diff --git a/rusty_pc/src/lazy.rs b/rusty_pc/src/lazy.rs
@@ -38,7 +38,7 @@ where
         }
     }
 
-    fn set_context(&mut self, _ctx: C) {
+    fn set_context(&mut self, _ctx: &C) {
         unimplemented!()
     }
 }
diff --git a/rusty_pc/src/lib.rs b/rusty_pc/src/lib.rs
@@ -14,6 +14,7 @@ mod lazy;
 pub mod many;
 pub mod many_ctx;
 pub mod map;
+pub mod map_ctx;
 pub mod map_err;
 mod or;
 pub mod or_default;
diff --git a/rusty_pc/src/many.rs b/rusty_pc/src/many.rs
@@ -60,7 +60,7 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/many_ctx.rs b/rusty_pc/src/many_ctx.rs
@@ -46,19 +46,21 @@ where
     type Error = P::Error;
     fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
         // set the default context before parsing begins
-        self.parser.set_context(CIn::default());
+        let mut ctx = CIn::default();
+        self.parser.set_context(&ctx);
         match self.parser.parse(input) {
             Ok(first_value) => {
                 // set the context to the underlying parser
-                self.parser
-                    .set_context((self.context_projection)(&first_value));
+                ctx = (self.context_projection)(&first_value);
+                self.parser.set_context(&ctx);
                 // seed the result
                 let mut result = self.combiner.seed(first_value);
                 loop {
                     match self.parser.parse(input) {
                         Ok(value) => {
                             // set the context of the underlying parser to the current value
-                            self.parser.set_context((self.context_projection)(&value));
+                            ctx = (self.context_projection)(&value);
+                            self.parser.set_context(&ctx);
                             // accumulate the result
                             result = self.combiner.accumulate(result, value);
                         }
@@ -83,5 +85,5 @@ where
         }
     }
 
-    fn set_context(&mut self, _ctx: COut) {}
+    fn set_context(&mut self, _ctx: &COut) {}
 }
diff --git a/rusty_pc/src/map.rs b/rusty_pc/src/map.rs
@@ -23,7 +23,7 @@ where
         self.parser.parse(tokenizer).map(&self.mapper)
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
@@ -54,7 +54,7 @@ where
         }
     }
 
-    fn set_context(&mut self, ctx: C) {
+    fn set_context(&mut self, ctx: &C) {
         self.parser.set_context(ctx)
     }
 }
diff --git a/rusty_pc/src/map_ctx.rs b/rusty_pc/src/map_ctx.rs
@@ -0,0 +1,41 @@
+use crate::{InputTrait, Parser};
+
+/// When setting the context of the underlying parser,
+/// this parser will transform it using the given mapper.
+pub struct MapCtxParser<P, F> {
+    parser: P,
+    context_mapper: F,
+}
+
+impl<P, F> MapCtxParser<P, F> {
+    pub fn new<I, COut, CIn>(parser: P, context_mapper: F) -> Self
+    where
+        P: Parser<I, CIn>,
+        F: Fn(&COut) -> CIn,
+        I: InputTrait,
+    {
+        Self {
+            parser,
+            context_mapper,
+        }
+    }
+}
+
+impl<I, COut, CIn, P, F> Parser<I, COut> for MapCtxParser<P, F>
+where
+    I: InputTrait,
+    P: Parser<I, CIn>,
+    F: Fn(&COut) -> CIn,
+{
+    type Output = P::Output;
+    type Error = P::Error;
+
+    fn parse(&mut self, input: &mut I) -> Result<Self::Output, Self::Error> {
+        self.parser.parse(input)
+    }
+
+    fn set_context(&mut self, ctx: &COut) {
+        let ctx_in = (self.context_mapper)(ctx);
+        self.parser.set_context(&ctx_in);
+    }
+}
diff --git a/rusty_pc/src/map_err.rs b/rusty_pc/src/map_err.rs
diff --git a/rusty_pc/src/or.rs b/rusty_pc/src/or.rs
diff --git a/rusty_pc/src/or_default.rs b/rusty_pc/src/or_default.rs
diff --git a/rusty_pc/src/parser.rs b/rusty_pc/src/parser.rs
diff --git a/rusty_pc/src/peek.rs b/rusty_pc/src/peek.rs
diff --git a/rusty_pc/src/seq.rs b/rusty_pc/src/seq.rs
diff --git a/rusty_pc/src/supplier.rs b/rusty_pc/src/supplier.rs
diff --git a/rusty_pc/src/surround.rs b/rusty_pc/src/surround.rs
diff --git a/rusty_pc/src/then_with.rs b/rusty_pc/src/then_with.rs
diff --git a/rusty_pc/src/then_with_left.rs b/rusty_pc/src/then_with_left.rs
diff --git a/rusty_pc/src/to_option.rs b/rusty_pc/src/to_option.rs
diff --git a/rusty_pc/src/top_level.rs b/rusty_pc/src/top_level.rs

Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,7 @@ fn parse_for_step_p() -> impl Parser<`
`43`	`43`	`Error = ParserError,`
`44`	`44`	`> {`
`45`	`45`	`parse_for_p().then_with_in_context(`
`46`		`- opt_step_p(),`
`47`		`- \|(_, _, upper)\| upper.is_parenthesis(),`
	`46`	`+ opt_step_p().map_ctx(\|(_, _, upper): &(_, _, ExpressionPos)\| upper.is_parenthesis()),`
`48`	`47`	`\|(n, l, u), opt_step\| (n, l, u, opt_step),`
`49`	`48`	`)`
`50`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,6 @@ pub fn sub_call_or_assignment_p() -> impl Parser<StringView, Output = Statement,`
`47`	`47`	`}`
`48`	`48`	`})`
`49`	`49`	`.flatten(),`
`50`		`- \|x\| x.clone(),`
`51`	`50`	`KeepRightCombiner,`
`52`	`51`	`)`
`53`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -123,8 +123,9 @@ where`
`123`	`123`	`{`
`124`	`124`	`name_with_opt_array(opt_array_parser_factory())`
`125`	`125`	`.then_with_in_context(`
`126`		`- var_type_parser(extended_type_parser_factory()),`
`127`		`- \|(name, _array)\| (name.qualifier(), !name.as_bare_name().contains('.')),`
	`126`	`+ var_type_parser(extended_type_parser_factory()).map_ctx(`
	`127`	`+ \|(name, _array): &(Name, _)\| (name.qualifier(), !name.as_bare_name().contains('.')),`
	`128`	`+ ),`
`128`	`129`	`TupleCombiner,`
`129`	`130`	`)`
`130`	`131`	`.map(\|((name, array), var_type)\| create_typed_name(name, array, var_type))`
Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,7 @@ fn followed_by_ws(`
`70`	`70`	`parser: impl Parser<StringView, Output = ExpressionPos, Error = ParserError>,`
`71`	`71`	`) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {`
`72`	`72`	`parser.then_with_in_context(`
`73`		`- conditionally_opt_whitespace(),`
`74`		`- \|e\| e.is_parenthesis(),`
	`73`	`+ conditionally_opt_whitespace().map_ctx(ExpressionTrait::is_parenthesis),`
`75`	`74`	`KeepLeftCombiner,`
`76`	`75`	`)`
`77`	`76`	`}`
`@@ -124,8 +123,8 @@ pub fn expr_ws_followed_by(`
`124`	`123`	`expr_parser.then_with_in_context(`
`125`	`124`	`conditionally_opt_whitespace()`
`126`	`125`	`.to_fatal()`
`127`		`- .and_keep_right(other_parser.to_fatal().no_context()),`
`128`		`- \|e\| e.is_parenthesis(),`
	`126`	`+ .and_keep_right(other_parser.to_fatal().no_context())`
	`127`	`+ .map_ctx(ExpressionTrait::is_parenthesis),`
`129`	`128`	`KeepLeftCombiner,`
`130`	`129`	`)`
`131`	`130`	`}`
`@@ -138,8 +137,7 @@ pub fn expr_keyword_opt_expr(`
`138`	`137`	`keyword: Keyword,`
`139`	`138`	`) -> impl Parser<StringView, Output = (ExpressionPos, Option<ExpressionPos>), Error = ParserError> {`
`140`	`139`	`expression_pos_p().then_with_in_context(`
`141`		`- opt_keyword_expr(keyword),`
`142`		`- ExpressionTrait::is_parenthesis,`
	`140`	`+ opt_keyword_expr(keyword).map_ctx(ExpressionTrait::is_parenthesis),`
`143`	`141`	`TupleCombiner,`
`144`	`142`	`)`
`145`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ where`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`- fn set_context(&mut self, ctx: C) {`
	`111`	`+ fn set_context(&mut self, ctx: &C) {`
`112`	`112`	`self.parser.set_context(ctx);`
`113`	`113`	`}`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ where`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`		`- fn set_context(&mut self, ctx: ()) {`
	`93`	`+ fn set_context(&mut self, ctx: &()) {`
`94`	`94`	`self.parser.set_context(ctx);`
`95`	`95`	`}`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ where`
`39`	`39`	`self.parser.parse(tokenizer).map(\|x\| x.at_pos(pos))`
`40`	`40`	`}`
`41`	`41`
`42`		`- fn set_context(&mut self, ctx: C) {`
	`42`	`+ fn set_context(&mut self, ctx: &C) {`
`43`	`43`	`self.parser.set_context(ctx)`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ where`
`196`	`196`	`self.parse_token(input)`
`197`	`197`	`}`
`198`	`198`
`199`		`- fn set_context(&mut self, ctx: C) {`
	`199`	`+ fn set_context(&mut self, ctx: &C) {`
`200`	`200`	`self.parser.set_context(ctx)`
`201`	`201`	`}`
`202`	`202`	`}`