context as parameter, remove IContextDependent

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs

@@ -15,7 +15,8 @@ public static void ReplaceTemplateParsingShouldHaveStepCount(string templatePath
     {
         var replaceTemplate = File.ReadAllText(templatePath);
         var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate);
-        var result = replaceBuilder.Build(ParsingContext.Empty);
+        IParsingContext context = ParsingContext.Empty;
+        var result = replaceBuilder.Build(ref context);
 
         Assert.NotNull(replaceTemplate);
         Assert.Equal(replaceBuilder.Steps.Count(), stepsCount);
@@ -37,13 +38,13 @@ public static void ReplaceBuildShouldBeSuccess(string templatePath, string resul
         var replaceResult = File.ReadAllText(resultPath);
         var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate);
 
-        var parsingContext = new ParsingContext(Input.Empty);
+        IParsingContext parsingContext = new ParsingContext(Input.Empty);
         for (int i = 0; i < keys.Length; i++)
         {
             parsingContext.AddPlaceholder(Placeholder.CreateEmpty(parsingContext, keys[i], values[i]));
         }
 
-        var result = replaceBuilder.Build(parsingContext);
+        var result = replaceBuilder.Build(ref parsingContext);
 
         Assert.NotNull(replaceTemplate);
         Assert.NotNull(replaceResult);

src/SimpleStateMachine.StructuralSearch/FindParser.cs

@@ -20,8 +20,7 @@ public IEnumerable<FindParserResult> Parse(ref IParsingContext context)
         {
             List<FindParserResult> matches = new();
             StringBuilder res = new();
-            Parser.SetContext(ref context);
-            
+
             var parsingContext = context;
             var parser = Parser.Select(x => string.Join(string.Empty, x))
                 .Match()

src/SimpleStateMachine.StructuralSearch/Parsers/DebugParser.cs

@@ -10,9 +10,9 @@ public DebugParser(Parser<TToken, T> parser)
             _parser = parser;
         }
 
-        public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expecteds, out T result)
+        public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expected, out T result)
         {
-            var res = _parser.TryParse(ref state, ref expecteds, out result);
+            var res = _parser.TryParse(ref state, ref expected, out result);
             return res;
         }
     }

src/SimpleStateMachine.StructuralSearch/Parsers/EmptyStringParser.cs

@@ -11,7 +11,7 @@ public EmptyStringParser(bool value)
             _value = value;
         }
 
-        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expecteds,
+        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,
             out string result)
         {
             result = string.Empty;

src/SimpleStateMachine.StructuralSearch/Parsers/EnumParser.cs

@@ -19,10 +19,10 @@ public EnumParser(bool ignoreCase, params TEnum [] excluded)
                 .AsEnum<TEnum>(ignoreCase);
         }
 
-        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expecteds,
+        public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,
             out TEnum result)
         {
-            return _parser.TryParse(ref state, ref expecteds, out result);
+            return _parser.TryParse(ref state, ref expected, out result);
         }
     }
 }

src/SimpleStateMachine.StructuralSearch/Parsers/IContextDependent.cs

@@ -0,0 +1,8 @@
+using Pidgin;
+
+namespace SimpleStateMachine.StructuralSearch;
+
+// public abstract class ParserWithContext<TToken, T> : Parser<TToken, T>
+// {
+//     public abstract bool TryParse(ref IParsingContext context, ref ParseState<TToken> state, ref PooledList<Expected<TToken>> expected, out T result);
+// }

src/SimpleStateMachine.StructuralSearch/Parsers/ParserWithContext.cs

@@ -28,15 +28,15 @@ public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expec
 
     public class LookaheadResult<TToken, T>
     {
+        public T Result { get; }
+        public int TokensCount { get; }
+        public readonly Parser<TToken, T> Parser;
+        
         public LookaheadResult(Parser<TToken, T> parser, T result, int tokensCount)
         {
             Parser = parser;
             Result = result;
             TokensCount = tokensCount;
         }
-
-        public T Result { get; }
-        public int TokensCount { get; }
-        public Parser<TToken, T> Parser;
     }
 }

src/SimpleStateMachine.StructuralSearch/Parsers/ParserWithLookahead.cs

@@ -5,17 +5,15 @@
 
 namespace SimpleStateMachine.StructuralSearch
 {
-    public class PlaceholderParser : ParserWithLookahead<char, string>, IContextDependent
+    public class PlaceholderParser : ParserWithLookahead<char, string>
     {
-        private IParsingContext _context;
-
+        private readonly string _name;
+        
         public PlaceholderParser(string name)
         {
-            Name = name;
+            _name = name;
         }
 
-        public string Name { get; }
-
         public override Parser<char, string> BuildParser(Func<Parser<char, string>?> next,
             Func<Parser<char, string>?> nextNext)
         {
@@ -79,9 +77,9 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
             out string result)
         {
             bool res;
-            
+
             // No use look-ahead if placeholder is already defined
-            if (_context.TryGetPlaceholder(Name, out var placeholder))
+            if (context.TryGetPlaceholder(_name, out var placeholder))
             {
                 res = Parser.String(placeholder.Value).TryParse(ref state, ref expected, out result);
             }
@@ -91,19 +89,14 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
                 result = match.Value;
                 if (res)
                 {
-                    _context.AddPlaceholder(new Placeholder(
-                        context: _context,
-                        name: Name,
+                    context.AddPlaceholder(new Placeholder(
+                        context: ref context,
+                        name: _name,
                         match: match));
                 }
             }
 
             return res;
         }
-        
-        public void SetContext(ref IParsingContext context)
-        {
-            _context = context;
-        }
     }
 }

src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs

@@ -4,7 +4,7 @@
     {
         private readonly Match<string> _match;
         private readonly IParsingContext _context;
-        public Placeholder(IParsingContext context, string name, Match<string> match)
+        public Placeholder(ref IParsingContext context, string name, Match<string> match)
         {
             _context = context;
             Name = name;
@@ -22,7 +22,7 @@ public Placeholder(IParsingContext context, string name, Match<string> match)
         public static Placeholder CreateEmpty(IParsingContext context, string name, string value)
         {
             return new Placeholder(
-                context: context,
+                context: ref context,
                 name: name,
                 new Match<string>(
                     value,