Simplify parsers

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/StructuralSearchTests.cs

@@ -47,12 +47,12 @@ public static void StructuralSearchShouldBeSuccess2(string filePath)
         var configuration = new Configuration
         {
             FindTemplate = "$Modificator$ $ReturnType$ $MethodName$($params$)",
-            FindRules = new List<string>
-            {
+            FindRules =
+            [
                 "$Modificator$ in (\"public\", \"private\", \"internal\")",
                 "$ReturnType$ is var",
                 "$MethodName$ is var"
-            }
+            ]
         };
 
         var parser = new StructuralSearchParser(configuration);

src/SimpleStateMachine.StructuralSearch/Constant.cs

@@ -153,26 +153,24 @@ internal static class Constant
         RightCurlyParenthesis
     };
 
-    public static class FindTemplate
+    public static readonly IReadOnlySet<char> InvalidStringLiteralChars = new HashSet<char>(AllParenthesis)
     {
-        public static readonly IReadOnlySet<char> All = new HashSet<char>(AllParenthesis)
-        {
-            PlaceholderSeparator,
-            CarriageReturn,
-            LineFeed,
-            Space
-        };
-    }
-
-    public static class Parameter
+        CarriageReturn,
+        LineFeed,
+        Space
+    };
+
+    public static readonly IReadOnlySet<char> All = new HashSet<char>(InvalidStringLiteralChars)
     {
-        public static readonly IReadOnlySet<char> Escape = new HashSet<char>
-        {
-            DoubleQuotes,
-            PlaceholderSeparator,
-            Dote
-        };
-
-        public static readonly IReadOnlySet<char> Excluded = AllParenthesis.Union(Escape).ToHashSet();
-    }
+        PlaceholderSeparator,
+    };
+
+    public static readonly IReadOnlySet<char> CharsToEscape = new HashSet<char>
+    {
+        DoubleQuotes,
+        PlaceholderSeparator,
+        Dote
+    };
+
+    public static readonly IReadOnlySet<char> LanguageSyntaxChars = AllParenthesis.Union(CharsToEscape).ToHashSet();
 }

src/SimpleStateMachine.StructuralSearch/Extensions/StringParserExtensions.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using Pidgin;
-using static Pidgin.Parser;
 
 namespace SimpleStateMachine.StructuralSearch.Extensions;
 
@@ -16,7 +15,7 @@ public static Parser<TToken, string> BetweenAsThen<TToken>(this Parser<TToken, s
         if (parser2 == null)
             throw new ArgumentNullException(nameof(parser2));
 
-        return Map<TToken, char, string, char, string>(
+        return Parser.Map<TToken, char, string, char, string>(
             (before, str, after) => before + str + after,
             parser1, parser, parser2);
     }
@@ -30,7 +29,7 @@ public static Parser<TToken, string> BetweenAsThen<TToken>(this Parser<TToken, s
         if (parser2 == null)
             throw new ArgumentNullException(nameof(parser2));
 
-        return Map<TToken, string, string, string, string>(
+        return Parser.Map<TToken, string, string, string, string>(
             (before, str, after) => before + str + after,
             parser1, parser, parser2);
     }
@@ -56,13 +55,13 @@ public static Parser<TToken, SourceMatch> AsMatch<TToken>(this Parser<TToken, st
         => parser.Then(Parser<TToken>.CurrentOffset, (s, offset) => new SourceMatch(s, offset - s.Length, offset));
 
     public static Parser<char, T> TrimEnd<T>(this Parser<char, T> parser)
-        => parser.Before(SkipWhitespaces);
+        => parser.Before(Parser.SkipWhitespaces);
 
     public static Parser<char, T> TrimStart<T>(this Parser<char, T> parser)
-        => parser.After(SkipWhitespaces);
+        => parser.After(Parser.SkipWhitespaces);
 
     public static Parser<char, T> Trim<T>(this Parser<char, T> parser)
-        => parser.Between(SkipWhitespaces);
+        => parser.Between(Parser.SkipWhitespaces);
 
     public static Parser<char, TEnum> AsEnum<TEnum>(this Parser<char, string> parser, bool ignoreCase)
         where TEnum : struct, Enum

src/SimpleStateMachine.StructuralSearch/Parsers/DebugParser.cs

@@ -1,7 +1,5 @@
 using Pidgin;
 
-#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
-
 namespace SimpleStateMachine.StructuralSearch.Parsers;
 
 internal class DebugParser<TToken, T> : Parser<TToken, T>

src/SimpleStateMachine.StructuralSearch/Parsers/EmptyStringParser.cs

@@ -1,7 +1,5 @@
 using Pidgin;
 
-#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
-
 namespace SimpleStateMachine.StructuralSearch.Parsers;
 
 internal class EmptyStringParser : Parser<char, string>

src/SimpleStateMachine.StructuralSearch/Parsers/ParserWithLookahead.cs

@@ -2,8 +2,6 @@
 using System.Collections.Generic;
 using Pidgin;
 
-#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
-
 namespace SimpleStateMachine.StructuralSearch.Parsers;
 
 internal abstract class ParserWithLookahead<TToken, T> : Parser<TToken, T>

src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs

@@ -3,14 +3,13 @@
 using System.Linq;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
-using static Pidgin.Parser;
 
 namespace SimpleStateMachine.StructuralSearch.Parsers;
 
 internal static class Parsers
 {
     public static Parser<char, string> String(string value, bool ignoreCase) 
-        => ignoreCase ? CIString(value): Parser.String(value);
+        => ignoreCase ? Parser.CIString(value): Parser.String(value);
 
     public static Parser<char, TEnum> After<TEnum>(TEnum value, bool ignoreCase = false)
         where TEnum : struct, Enum 
@@ -23,7 +22,7 @@ private static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken
         ArgumentNullException.ThrowIfNull(parser2);
         ArgumentNullException.ThrowIfNull(parser3);
 
-        return Map((arg1, arg2, arg3) => (IEnumerable<T>)new List<T> { arg1, arg2, arg3 }, parser1, parser2, parser3);
+        return Parser.Map((arg1, arg2, arg3) => (IEnumerable<T>)new List<T> { arg1, arg2, arg3 }, parser1, parser2, parser3);
     }
 
     private static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken, T> parser1,
@@ -33,7 +32,7 @@ private static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken
         ArgumentNullException.ThrowIfNull(parser2);
         ArgumentNullException.ThrowIfNull(parser3);
 
-        return Map((arg1, arg2, arg3) =>
+        return Parser.Map((arg1, arg2, arg3) =>
         {
             var result = arg2.ToList();
             result.Insert(0, arg1);
@@ -50,7 +49,7 @@ public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken,
         if (parser2 == null)
             throw new ArgumentNullException(nameof(parser2));
 
-        return Map((arg1, arg2) =>
+        return Parser.Map((arg1, arg2) =>
         {
             var result = new List<T> { arg1, arg2 };
             return (IEnumerable<T>)result;
@@ -63,13 +62,13 @@ public static Parser<char, IEnumerable<T>> BetweenChars<T>(char left, char right
         => MapToMany(leftRight(left), expr, leftRight(right));
 
     public static Parser<char, IEnumerable<T>> BetweenOneOfChars<T>(Func<char, Parser<char, T>> leftRight, Parser<char, IEnumerable<T>> expr, params (char, char)[] values) 
-        => OneOf(values.Select(x => MapToMany(leftRight(x.Item1), expr, leftRight(x.Item2))));
+        => Parser.OneOf(values.Select(x => MapToMany(leftRight(x.Item1), expr, leftRight(x.Item2))));
 
     public static Parser<char, IEnumerable<T>> BetweenOneOfChars<T>(Func<char, Parser<char, T>> leftRight, Parser<char, T> expr, params (char, char)[] values) 
-        => OneOf(values.Select(x => MapToMany(leftRight(x.Item1), expr, leftRight(x.Item2))));
+        => Parser.OneOf(values.Select(x => MapToMany(leftRight(x.Item1), expr, leftRight(x.Item2))));
 
     public static Parser<char, (TResult, T)> BetweenOneOfChars<T, TResult>(Func<char, char, TResult> resultFunc, Parser<char, T> expr, params (char, char)[] values) 
-        => OneOf(values.Select(x => Map((c1, res, c2) => (resultFunc(c1, c2), res), Char(x.Item1).Try(), expr, Char(x.Item2).Try())));
+        => Parser.OneOf(values.Select(x => Parser.Map((c1, res, c2) => (resultFunc(c1, c2), res), Parser.Char(x.Item1).Try(), expr, Parser.Char(x.Item2).Try())));
 
     public static Parser<char, TEnum> EnumExcept<TEnum>(bool ignoreCase = false, params TEnum[] excluded)
         where TEnum : struct, Enum 
@@ -80,7 +79,7 @@ public static Parser<char, TEnum> EnumValue<TEnum>(TEnum value, bool ignoreCase
         => String(value.ToString(), ignoreCase).AsEnum<TEnum>(ignoreCase);
 
     public static Parser<char, Match<T>> Match<T>(Parser<char, T> parser) 
-        => Map((oldPos, oldOffset, result, newPos, newOffset) =>
+        => Parser.Map((oldPos, oldOffset, result, newPos, newOffset) =>
             {
                 var line = new LinePosition(oldPos.Line, newPos.Line);
                 var column = new ColumnPosition(oldPos.Col, newPos.Col);

src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs

@@ -53,10 +53,10 @@ protected override Parser<char, string> BuildParser(Func<Parser<char, string>?>
             }).Try());
         }
 
-        var anyString = CommonTemplateParser.AnyCharWithPlaceholder
+        var anyString = CommonTemplateParser.StringLiteralChar
             .AtLeastOnceAsStringUntil(lookahead);
 
-        var simpleString = CommonTemplateParser.StringWithPlaceholder;
+        var simpleString = CommonTemplateParser.StringLiteral;
         var token = Parser.OneOf(simpleString, CommonParser.WhiteSpaces).Try();
         Parser<char, string>? term = null;
 

src/SimpleStateMachine.StructuralSearch/Parsers/SeriesParser.cs

@@ -3,8 +3,6 @@
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Context;
 
-#pragma warning disable CS9074 // The 'scoped' modifier of parameter doesn't match overridden or implemented member.
-
 namespace SimpleStateMachine.StructuralSearch.Parsers;
 
 internal class SeriesParser : Parser<char, IEnumerable<string>>, IContextDependent

src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringParameter.cs

@@ -16,7 +16,7 @@ public string GetValue(ref IParsingContext context)
 
     public override string ToString()
     {
-        var value = EscapeHelper.EscapeChars(_value, c => $"{Constant.BackSlash}{c}", Constant.Parameter.Escape);
+        var value = EscapeHelper.EscapeChars(_value, c => $"{Constant.BackSlash}{c}", Constant.CharsToEscape);
         return $"{value}";
     }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonParser.cs

@@ -1,28 +1,28 @@
 using System;
 using System.Collections.Generic;
+using System.Text;
 using Pidgin;
-using static Pidgin.Parser;
 
 namespace SimpleStateMachine.StructuralSearch.StructuralSearch;
 
 internal static class CommonParser
 {
     internal static readonly Parser<char, string> Empty = Parsers.Parsers.String(Constant.EmptyString, false);
-    internal static readonly Parser<char, char> AnyChar = AnyCharExcept(Constant.FindTemplate.All);
-    internal static readonly Parser<char, char> Space = Char(Constant.Space);
+    internal static readonly Parser<char, char> Space = Parser.Char(Constant.Space);
+    internal static readonly Parser<char, char> Underscore = Parser.Char(Constant.Underscore);
     internal static readonly Parser<char, Unit> Eof = Parser<char>.End;
-    internal static readonly Parser<char, string> AnyString = AnyChar.AtLeastOnceString();
+    internal static readonly Parser<char, string> AnyString = Parser.AnyCharExcept(Constant.All).AtLeastOnceString();
     internal static readonly Parser<char, string> Spaces = Space.AtLeastOnceString();
-    internal static readonly Parser<char, string> LineEnds = EndOfLine.AtLeastOnceString();
-    internal static readonly Parser<char, string> WhiteSpaces = OneOf(Spaces, LineEnds, LineEnds).AtLeastOnceString();
-    internal static readonly Parser<char, string> Identifier = Letter.Then(AnyString, (h, t) => h + t);
-    internal static readonly Parser<char, char> Comma = Char(Constant.Comma);
-    internal static readonly Parser<char, char> Colon = Char(Constant.Colon);
-    internal static readonly Parser<char, char> DoubleQuotes = Char(Constant.DoubleQuotes);
-    internal static readonly Parser<char, char> SingleQuotes = Char(Constant.SingleQuotes);
-    internal static readonly Parser<char, char> Dote = Char(Constant.Dote);
-    internal static readonly Parser<char, char> Underscore = Char(Constant.Underscore);
-    internal static readonly Parser<char, char> PlaceholderSeparator = Char(Constant.PlaceholderSeparator);
+    internal static readonly Parser<char, string> LineEnds = Parser.EndOfLine.AtLeastOnceString();
+    internal static readonly Parser<char, string> WhiteSpaces = Parser.OneOf(Spaces, LineEnds, LineEnds).AtLeastOnceString();
+    internal static readonly Parser<char, string> Identifier = Parser.Letter.Then(Parser.OneOf(Parser.Letter, Parser.Digit, Underscore).AtLeastOnce(), BuildString);
+    internal static readonly Parser<char, char> Comma = Parser.Char(Constant.Comma);
+    internal static readonly Parser<char, char> Colon = Parser.Char(Constant.Colon);
+    internal static readonly Parser<char, char> DoubleQuotes = Parser.Char(Constant.DoubleQuotes);
+    internal static readonly Parser<char, char> SingleQuotes = Parser.Char(Constant.SingleQuotes);
+    internal static readonly Parser<char, char> Dote = Parser.Char(Constant.Dote);
+
+    internal static readonly Parser<char, char> PlaceholderSeparator = Parser.Char(Constant.PlaceholderSeparator);
 
     internal static Parser<char, T> Parenthesised<T, TResult>(Parser<char, T> parser,
         Func<char, Parser<char, TResult>> custom)
@@ -32,5 +32,17 @@ internal static Parser<char, T> Parenthesised<T, TResult>(Parser<char, T> parser
             custom(Constant.RightParenthesis)
         );
 
-    internal static Parser<char, char> Escaped(IEnumerable<char> chars) => Char(Constant.BackSlash).Then(OneOf(chars));
+    internal static Parser<char, char> Escaped(IEnumerable<char> chars) =>
+        Parser.Char(Constant.BackSlash).Then(Parser.OneOf(chars));
+
+    private static string BuildString(char c, IEnumerable<char> chars)
+    {
+        var builder = new StringBuilder();
+        builder.Append(c);
+
+        foreach (var value in chars)
+            builder.Append(value);
+
+        return builder.ToString();
+    }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonTemplateParser.cs

@@ -1,13 +1,12 @@
 using System.Linq;
 using Pidgin;
-using static Pidgin.Parser;
 
 namespace SimpleStateMachine.StructuralSearch.StructuralSearch;
 
 internal static class CommonTemplateParser
 {
-    internal static readonly Parser<char, char> AnyCharWithPlaceholder = AnyCharExcept(Constant.FindTemplate.All.Except([Constant.PlaceholderSeparator]));
+    internal static readonly Parser<char, char> StringLiteralChar = Parser.AnyCharExcept(Constant.InvalidStringLiteralChars);
     internal static readonly Parser<char, string> Placeholder = CommonParser.Identifier.Between(CommonParser.PlaceholderSeparator);
-    internal static readonly Parser<char, string> StringWithPlaceholder = AnyCharWithPlaceholder.AtLeastOnceString();
-    internal static readonly Parser<char, string> Should = String(Constant.Should);
+    internal static readonly Parser<char, string> StringLiteral = StringLiteralChar.AtLeastOnceString();
+    internal static readonly Parser<char, string> Should = Parser.String(Constant.Should);
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs

@@ -9,24 +9,15 @@ namespace SimpleStateMachine.StructuralSearch.StructuralSearch;
 
 internal static class FindRuleParser
 {
-    private static Parser<char, Func<IFindRule, IFindRule>> UnaryOperation(UnaryRuleType ruleType)
-        => Parsers.Parsers.EnumValue(ruleType, true).Trim().Try()
-            .Select<Func<IFindRule, IFindRule>>(type => param => new UnaryRule(type, param));
-
-    private static Parser<char, Func<IFindRule, IFindRule, IFindRule>> BinaryOperation(BinaryRuleType ruleType)
-        => Parsers.Parsers.EnumValue(ruleType, true).Trim().Try()
-            .Select<Func<IFindRule, IFindRule, IFindRule>>(type => (left, right) => new BinaryRule(type, left, right));
-
     private static readonly Parser<char, Func<IFindRule, IFindRule, IFindRule>> And = BinaryOperation(BinaryRuleType.And);
     private static readonly Parser<char, Func<IFindRule, IFindRule, IFindRule>> Or = BinaryOperation(BinaryRuleType.Or);
     private static readonly Parser<char, Func<IFindRule, IFindRule, IFindRule>> NOR = BinaryOperation(BinaryRuleType.NOR);
     private static readonly Parser<char, Func<IFindRule, IFindRule, IFindRule>> XOR = BinaryOperation(BinaryRuleType.XOR);
     private static readonly Parser<char, Func<IFindRule, IFindRule, IFindRule>> NAND = BinaryOperation(BinaryRuleType.NAND);
     private static readonly Parser<char, Func<IFindRule, IFindRule, IFindRule>> XNOR = BinaryOperation(BinaryRuleType.XNOR);
-
     private static readonly Parser<char, Func<IFindRule, IFindRule>> Not = UnaryOperation(UnaryRuleType.Not);
 
-    public static readonly Parser<char, IFindRule> Expr = ExpressionParser.Build<char, IFindRule>
+    internal static readonly Parser<char, IFindRule> Expr = ExpressionParser.Build<char, IFindRule>
     (
         rule =>
         (
@@ -51,4 +42,12 @@ internal static IFindRule ParseTemplate(string? str)
         => string.IsNullOrEmpty(str)
             ? Rule.Empty
             : Expr.Before(CommonParser.Eof).ParseOrThrow(str);
+
+    private static Parser<char, Func<IFindRule, IFindRule>> UnaryOperation(UnaryRuleType ruleType)
+        => Parsers.Parsers.EnumValue(ruleType, true).Trim().Try()
+            .Select<Func<IFindRule, IFindRule>>(type => param => new UnaryRule(type, param));
+
+    private static Parser<char, Func<IFindRule, IFindRule, IFindRule>> BinaryOperation(BinaryRuleType ruleType)
+        => Parsers.Parsers.EnumValue(ruleType, true).Trim().Try()
+            .Select<Func<IFindRule, IFindRule, IFindRule>>(type => (left, right) => new BinaryRule(type, left, right));
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs

@@ -16,7 +16,8 @@ internal static class FindTemplateParser
         ParserToParser.ParserAsParser(CommonParser.WhiteSpaces).Try();
 
     private static readonly Parser<char, Parser<char, string>> Placeholder =
-        CommonTemplateParser.Placeholder.Select(name => new PlaceholderParser(name))
+        CommonTemplateParser.Placeholder
+            .Select(name => new PlaceholderParser(name))
             .As<char, PlaceholderParser, Parser<char, string>>();
 
     private static readonly Parser<char, IEnumerable<Parser<char, string>>> Token =
@@ -30,7 +31,7 @@ internal static class FindTemplateParser
             values: Constant.AllParentheses
         );
 
-    internal static Parser<char, IEnumerable<Parser<char, string>>> Term =
+    private static readonly Parser<char, IEnumerable<Parser<char, string>>> Term =
         Parser.OneOf(Parenthesised, Token).Many().SelectMany();
 
     private static readonly Parser<char, IEnumerable<Parser<char, string>>> TemplateParser =