Optimization parameters, escape dote for string parameter, new replace template parsing

RomanSoloweow · RomanSoloweow · commit e9cd5d845f54 · 2022-05-13T03:58:44.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Sandbox/Expr.cs b/src/SimpleStateMachine.StructuralSearch.Sandbox/Expr.cs
@@ -137,6 +137,7 @@ public double Invoke()
                 BinaryOperatorType.Mul => Left.Invoke() * Right.Invoke(),
                 BinaryOperatorType.Div => Left.Invoke() / Right.Invoke(),
                 BinaryOperatorType.Sub => Left.Invoke() - Right.Invoke(),
+                _ => throw new ArgumentOutOfRangeException()
             };
         }
     }
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFile/FullConfig.yml b/src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFile/FullConfig.yml
@@ -20,7 +20,7 @@
           $var$ = $value1$;
     FindRules:
       - $sign$ In ("Is", "==", "!=", "is not")
-      - $value$ In ($value1$, "$value1$.Value",  $value2$, "$value2$.Value")
+      - $value$ In ($value1$, "$value1$\.Value",  $value2$, "$value2$\.Value")
     ReplaceTemplate: |-
       $var$ = $value1$ ?? $value2$;
     ReplaceRules:  
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFile/ShortConfig.yml b/src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFile/ShortConfig.yml
@@ -19,7 +19,7 @@
           $var$ = $value1$;
     FindRules:
       - $sign$ In ("Is", "==", "!=", "is not")
-      - $value$ In ($value1$, "$value1$.Value",  $value2$, "$value2$.Value")
+      - $value$ In ($value1$, "$value1$\.Value",  $value2$, "$value2$\.Value")
     ReplaceTemplate: |-
       $var$ = $value1$ ?? $value2$;
     ReplaceRules:  
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindRule/NullUnionOperator.txt b/src/SimpleStateMachine.StructuralSearch.Tests/FindRule/NullUnionOperator.txt
@@ -1,2 +1,2 @@
 ﻿$sign$ In ("Is", "==", "!=", "is not")
-$value$ In ($value1$, "$value1$.Value",  $value2$, "$value2$.Value")
+$value$ In ($value1$, "$value1$\.Value",  $value2$, "$value2$\.Value")
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs
@@ -50,7 +50,7 @@ public void FindRuleExprParsingShouldBeEqualsCustomResult(string ruleStr, string
             Assert.Equal(_ruleStr, customResult.ToLower());
         }
         [Theory]
-        [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"",  "$value$ In $value1$,\"$value1$.Value\",$value2$,\"$value2$.Value\"")]
+        [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"",  "$value$ In $value1$,\"$value1$\\.Value\",$value2$,\"$value2$\\.Value\"")]
         [InlineData("FindRule/AssignmentNullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"")]
         public void FindRuleParsingFromFileShouldBeSuccess(string filePath, params string[] customResult)
         {
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs
@@ -10,9 +10,9 @@ namespace SimpleStateMachine.StructuralSearch.Tests
     public class ReplaceTemplateTests
     {
         [Theory]
-        [InlineData("ReplaceTemplate/NullUnionOperator.txt", 10)]
-        [InlineData("ReplaceTemplate/AssignmentNullUnionOperator.txt", 6)]
-        [InlineData("ReplaceTemplate/TernaryOperator.txt", 11)]
+        [InlineData("ReplaceTemplate/NullUnionOperator.txt", 6)]
+        [InlineData("ReplaceTemplate/AssignmentNullUnionOperator.txt", 4)]
+        [InlineData("ReplaceTemplate/TernaryOperator.txt", 7)]
         public void ReplaceTemplateParsingShouldHaveStepCount(string templatePath, int stepsCount)
         {
             var replaceTemplate = File.ReadAllText(templatePath);
diff --git a/src/SimpleStateMachine.StructuralSearch/Constant.cs b/src/SimpleStateMachine.StructuralSearch/Constant.cs
@@ -1,4 +1,6 @@
-﻿namespace SimpleStateMachine.StructuralSearch
+﻿using System.Linq;
+
+namespace SimpleStateMachine.StructuralSearch
 {
     public static partial class Constant
     {
@@ -136,5 +138,18 @@ public static partial class Constant
         /// Parenthesis chars: '(' and ')', '{ and '}', '{ and '}'
         /// </summary>
         public static readonly (char, char)[] AllParenthesised = { Parenthesis, SquareParenthesis, CurlyParenthesis };
+        
+        /// <summary>
+        /// Parenthesis chars: '(' and ')', '{ and '}', '{ and '}'
+        /// </summary>
+        public static readonly char[] AllParenthesisArray = 
+        {
+            LeftParenthesis,
+            RightParenthesis,
+            LeftSquareParenthesis,
+            RightSquareParenthesis,
+            LeftCurlyParenthesis,
+            RightCurlyParenthesis
+        };
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/ArrayExpression.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/ArrayExpression.cs
@@ -0,0 +1,13 @@
+﻿using System.Linq;
+
+namespace SimpleStateMachine.StructuralSearch.Extensions;
+
+public static class ArrayExpression
+{
+    public static T[] Add<T>(this T[] array, params  T[] values)
+    {
+        var list = array.ToList();
+        list.AddRange(values);
+        return list.ToArray();
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/BinarySubRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/BinarySubRule.cs
@@ -3,15 +3,15 @@
 
 namespace SimpleStateMachine.StructuralSearch.Rules
 {
-    public class SubRule : IRule
+    public class BinarySubRule : IRule
     {
         public SubRuleType Type { get; }
         
         public IRuleParameter Left { get; }
         
         public IRuleParameter Right { get; }
         
-        public SubRule(SubRuleType type, IRuleParameter left, IRuleParameter right)
+        public BinarySubRule(SubRuleType type, IRuleParameter left, IRuleParameter right)
         {
             Type = type;
             Left = left;
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderPropertyParser.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderPropertyParser.cs
@@ -45,13 +45,19 @@ public static class PlaceholderPropertyParser
                 .Select(property => new Func<PlaceholderParameter, IRuleParameter>(placeholder => 
                     new PlaceholderLenghtParameter(placeholder, property)))
                 .Try();
-
-        public static readonly Parser<char, IRuleParameter> PlaceholderPropertyParameter =
-            CommonTemplateParser.Placeholder.Before(CommonParser.Dote)
-                .Select(name => new PlaceholderParameter(name))
-                .Then(Parser.OneOf(Lenght, File, Column, Offset, Line),
-                    (placeholder, func) => func(placeholder))
-                .TrimStart()
+        
+        public static readonly Parser<char, Func<PlaceholderParameter, IRuleParameter>> PlaceholderPropertyParameter =
+            CommonParser.Dote.Then(Parser.OneOf(Lenght, File, Column, Offset, Line)).Optional()
+                .Select(property => new Func<PlaceholderParameter, IRuleParameter>(placeholder =>
+                    property.HasValue ? property.Value(placeholder) : placeholder))
                 .Try();
+        
+        // public static readonly Parser<char, IRuleParameter> PlaceholderPropertyParameter =
+        //     CommonTemplateParser.Placeholder.Before(CommonParser.Dote)
+        //         .Select(name => new PlaceholderParameter(name))
+        //         .Then(Parser.OneOf(Lenght, File, Column, Offset, Line),
+        //             (placeholder, func) => func(placeholder))
+        //         .TrimStart()
+        //         .Try();
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringParameter.cs
@@ -16,8 +16,7 @@ public string GetValue()
         
         public override string ToString()
         {
-            var value = EscapeHelper.EscapeChars(Value, c => $"{Constant.BackSlash}{c}", Constant.PlaceholderSeparator,
-                Constant.DoubleQuotes);
+            var value = EscapeHelper.EscapeChars(Value, c => $"{Constant.BackSlash}{c}", Constant.Parameter.Escape);
             
             return $"{value}";
         } 
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonParser.cs
@@ -10,7 +10,7 @@ internal static readonly Parser<char, string> Empty
             = Parsers.String(Constant.Empty, false);
         
         internal static readonly Parser<char, char> AnyChar
-            = AnyCharExcept(Constant.FindTemplate.All());
+            = AnyCharExcept(Constant.FindTemplate.All);
         
         internal static readonly Parser<char, char> Space
             = Char(Constant.Space);
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ParametersParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ParametersParser.cs
@@ -1,4 +1,5 @@
-﻿using System.Collections.Generic;
+﻿using System;
+using System.Collections.Generic;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.Rules;
@@ -13,34 +14,45 @@ public static class ParametersParser
                 .TrimStart()
                 .Try();
 
-        public static readonly Parser<char, IRuleParameter> PlaceholderRuleParameter =
-            PlaceholderParameter
-                .As<char, PlaceholderParameter, IRuleParameter>();
+        // public static readonly Parser<char, IRuleParameter> PlaceholderRuleParameter =
+        //     PlaceholderParameter
+        //         .As<char, PlaceholderParameter, IRuleParameter>();
+
+        public static readonly Parser<char, IRuleParameter> PlaceholderOrPropertyRuleParameter =
+            PlaceholderParameter.Then(PlaceholderPropertyParser.PlaceholderPropertyParameter,
+                    (placeholder, func) => func(placeholder))
+                .Try();
 
         public static readonly Parser<char, IRuleParameter> StringParameter =
-            CommonParser.Escaped(Constant.DoubleQuotes, Constant.PlaceholderSeparator)
-                .Or(Parser.AnyCharExcept(Constant.DoubleQuotes, Constant.PlaceholderSeparator))
+            CommonParser.Escaped(Constant.Parameter.Escape)
+                .Or(Parser.AnyCharExcept(Constant.Parameter.Excluded))
                 .AtLeastOnceString()
                 .Select(x => new StringParameter(x))
                 .As<char, StringParameter, IRuleParameter>()
                 .Try();
-        
+
         public static readonly Parser<char, IRuleParameter> StringFormatParameter =
-            Parser.OneOf(StringParameter, PlaceholderPropertyParser.PlaceholderPropertyParameter, PlaceholderRuleParameter)
+            Parser.OneOf(PlaceholderOrPropertyRuleParameter, StringParameter)
                 .AtLeastOnce()
                 .Between(CommonParser.DoubleQuotes)
                 .Select(parameters => new StringFormatParameter(parameters))
                 .As<char, StringFormatParameter, IRuleParameter>()
                 .TrimStart()
                 .Try();
-        
+
         public static readonly Parser<char, IRuleParameter> Parameter =
-            Parser.OneOf(PlaceholderPropertyParser.PlaceholderPropertyParameter, PlaceholderRuleParameter, StringFormatParameter)
+            Parser.OneOf(StringFormatParameter, PlaceholderOrPropertyRuleParameter)
                 .TrimStart()
                 .Try();
 
         public static readonly Parser<char, IEnumerable<IRuleParameter>> Parameters =
             Parameter.SeparatedAtLeastOnce(CommonParser.Comma);
 
+        public static readonly Parser<char, Func<IRuleParameter, IRuleParameter>> ChangeTypeParameter =
+            CommonParser.Dote.Then(Parser.CIEnum<ChangeType>())
+                .Optional()
+                .Select(changeType => new Func<IRuleParameter, IRuleParameter>(placeholder =>
+                    changeType.HasValue ? new ChangeParameter(placeholder, changeType.Value) : placeholder))
+                .Try();
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceRuleParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceRuleParser.cs
@@ -1,4 +1,6 @@
-﻿using Pidgin;
+﻿using System;
+using System.Collections.Generic;
+using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.Rules;
 
@@ -10,20 +12,13 @@ public static class ReplaceRuleParser
             Parser.CIString(Constant.Then)
                 .Try()
                 .TrimStart();
-
-        internal static readonly Parser<char, IRuleParameter> ReplaceSubRuleParameter =
-            Parser.Map((parameter, changeType) =>
-                        changeType.HasValue ? new ChangeParameter(parameter, changeType.Value) : parameter,
-                    ParametersParser.Parameter,
-                    CommonParser.Dote.Then(Parser.CIEnum<ChangeType>()).Optional())
-                .Try()
-                .TrimStart();
-
+        
         internal static readonly Parser<char, ReplaceSubRule> ReplaceSubRule =
             Parser.Map((placeholder, _, parameter) => new ReplaceSubRule(placeholder, parameter),
                     ParametersParser.PlaceholderParameter.TrimStart(),
                     CommonTemplateParser.Should.TrimStart(),
-                    ReplaceSubRuleParameter)
+                    ParametersParser.Parameter
+                        .Then(ParametersParser.ChangeTypeParameter, (parameter, func) => func(parameter)))
                 .Try()
                 .TrimStart();
 
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs
@@ -2,55 +2,73 @@
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.ReplaceTemplate;
+using SimpleStateMachine.StructuralSearch.Rules;
 
 namespace SimpleStateMachine.StructuralSearch
 {
     internal class ReplaceTemplateParser
     {
-        static ReplaceTemplateParser()
-        {
-            Parenthesised = Parsers.BetweenOneOfChars(x=> ParserToReplace.Stringc(x),
-                Parser.Rec(() => Term),
-                Constant.AllParenthesised);
-
-            Term = Parser.OneOf(Parenthesised, Token)
-                .Many()
-                .MergerMany();
-
-            TemplateParser = Parser.OneOf(Parenthesised, Token)
-                .AtLeastOnceUntil(CommonParser.EOF)
-                .MergerMany();
-        }
-
-        internal static readonly Parser<char, IReplaceStep> Empty = 
-            ParserToReplace.ResultAsReplace(CommonParser.Empty);
-
-        internal static readonly Parser<char, IReplaceStep> AnyString = 
-            ParserToReplace.ResultAsReplace(CommonParser.AnyString)
+        // static ReplaceTemplateParser()
+        // {
+        //     Parenthesised = Parsers.BetweenOneOfChars(x=> ParserToReplace.Stringc(x),
+        //         Parser.Rec(() => Term),
+        //         Constant.AllParenthesised);
+        //
+        //     Term = Parser.OneOf(Parenthesised, Token)
+        //         .Many()
+        //         .MergerMany();
+        //
+        //     TemplateParser = Parser.OneOf(Parenthesised, Token)
+        //         .AtLeastOnceUntil(CommonParser.EOF)
+        //         .MergerMany();
+        // }
+        //
+        // internal static readonly Parser<char, IReplaceStep> Empty = 
+        //     ParserToReplace.ResultAsReplace(CommonParser.Empty);
+        //
+        // internal static readonly Parser<char, IReplaceStep> AnyString = 
+        //     ParserToReplace.ResultAsReplace(CommonParser.AnyString)
+        //         .Try();
+        //
+        // internal static readonly Parser<char, IReplaceStep> WhiteSpaces =
+        //     ParserToReplace.ResultAsReplace(CommonParser.WhiteSpaces)
+        //         .Try();
+        //
+        // internal static readonly Parser<char, IReplaceStep> Placeholder =
+        //     CommonTemplateParser.Placeholder.Select(name=> new PlaceholderReplace(name))
+        //         .As<char, PlaceholderReplace, IReplaceStep>()
+        //         .Try();
+        //
+        // internal static readonly Parser<char, IEnumerable<IReplaceStep>> Token =
+        //     Parser.OneOf(AnyString, Placeholder, WhiteSpaces)
+        //         .AsMany();
+        //
+        // internal static readonly Parser<char, IEnumerable<IReplaceStep>> Term;
+        //
+        // internal static readonly Parser<char, IEnumerable<IReplaceStep>> Parenthesised;
+        //
+        // internal static readonly Parser<char, IEnumerable<IReplaceStep>> TemplateParser;
+        //
+        // internal static IReplaceBuilder ParseTemplate(string str)
+        // {
+        //     return TemplateParser
+        //         .Select(steps => new ReplaceBuilder(steps))
+        //         .ParseOrThrow(str);
+        // }
+        
+        public static readonly Parser<char, IRuleParameter> Parameter =
+            Parser.OneOf(ParametersParser.StringParameter,
+                    ParametersParser.PlaceholderOrPropertyRuleParameter)
+                .Then(ParametersParser.ChangeTypeParameter, (parameter, func) => func(parameter))
                 .Try();
 
-        internal static readonly Parser<char, IReplaceStep> WhiteSpaces =
-            ParserToReplace.ResultAsReplace(CommonParser.WhiteSpaces)
+        public static readonly Parser<char, IEnumerable<IRuleParameter>> Parameters =
+            Parameter.AtLeastOnceUntil(CommonParser.EOF)
                 .Try();
-
-        internal static readonly Parser<char, IReplaceStep> Placeholder =
-            CommonTemplateParser.Placeholder.Select(name=> new PlaceholderReplace(name))
-                .As<char, PlaceholderReplace, IReplaceStep>()
-                .Try();
-
-        internal static readonly Parser<char, IEnumerable<IReplaceStep>> Token =
-            Parser.OneOf(AnyString, Placeholder, WhiteSpaces)
-                .AsMany();
-
-        internal static readonly Parser<char, IEnumerable<IReplaceStep>> Term;
-
-        internal static readonly Parser<char, IEnumerable<IReplaceStep>> Parenthesised;
-
-        internal static readonly Parser<char, IEnumerable<IReplaceStep>> TemplateParser;
-
+        
         internal static IReplaceBuilder ParseTemplate(string str)
         {
-            return TemplateParser
+            return Parameters
                 .Select(steps => new ReplaceBuilder(steps))
                 .ParseOrThrow(str);
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/SubRuleParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/SubRuleParser.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/FindTemplate/ConstantFindTemplate.cs b/src/SimpleStateMachine.StructuralSearch/Templates/FindTemplate/ConstantFindTemplate.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/IReplaceBuilder.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/IReplaceBuilder.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/ReplaceBuilder.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/ReplaceBuilder.cs

Original file line number	Diff line number	Diff line change
`@@ -137,6 +137,7 @@ public double Invoke()`
`137`	`137`	`BinaryOperatorType.Mul => Left.Invoke() * Right.Invoke(),`
`138`	`138`	`BinaryOperatorType.Div => Left.Invoke() / Right.Invoke(),`
`139`	`139`	`BinaryOperatorType.Sub => Left.Invoke() - Right.Invoke(),`
	`140`	`+ _ => throw new ArgumentOutOfRangeException()`
`140`	`141`	`};`
`141`	`142`	`}`
`142`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`$sign$ In ("Is", "==", "!=", "is not")`
`2`		`-$value$ In ($value1$, "$value1$.Value", $value2$, "$value2$.Value")`
	`2`	`+$value$ In ($value1$, "$value1$\.Value", $value2$, "$value2$\.Value")`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public void FindRuleExprParsingShouldBeEqualsCustomResult(string ruleStr, string`
`50`	`50`	`Assert.Equal(_ruleStr, customResult.ToLower());`
`51`	`51`	`}`
`52`	`52`	`[Theory]`
`53`		`- [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"", "$value$ In $value1$,\"$value1$.Value\",$value2$,\"$value2$.Value\"")]`
	`53`	`+ [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"", "$value$ In $value1$,\"$value1$\\.Value\",$value2$,\"$value2$\\.Value\"")]`
`54`	`54`	`[InlineData("FindRule/AssignmentNullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"")]`
`55`	`55`	`public void FindRuleParsingFromFileShouldBeSuccess(string filePath, params string[] customResult)`
`56`	`56`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,9 +10,9 @@ namespace SimpleStateMachine.StructuralSearch.Tests`
`10`	`10`	`public class ReplaceTemplateTests`
`11`	`11`	`{`
`12`	`12`	`[Theory]`
`13`		`- [InlineData("ReplaceTemplate/NullUnionOperator.txt", 10)]`
`14`		`- [InlineData("ReplaceTemplate/AssignmentNullUnionOperator.txt", 6)]`
`15`		`- [InlineData("ReplaceTemplate/TernaryOperator.txt", 11)]`
	`13`	`+ [InlineData("ReplaceTemplate/NullUnionOperator.txt", 6)]`
	`14`	`+ [InlineData("ReplaceTemplate/AssignmentNullUnionOperator.txt", 4)]`
	`15`	`+ [InlineData("ReplaceTemplate/TernaryOperator.txt", 7)]`
`16`	`16`	`public void ReplaceTemplateParsingShouldHaveStepCount(string templatePath, int stepsCount)`
`17`	`17`	`{`
`18`	`18`	`var replaceTemplate = File.ReadAllText(templatePath);`
Original file line number	Diff line number	Diff line change
`@@ -3,15 +3,15 @@`
`3`	`3`
`4`	`4`	`namespace SimpleStateMachine.StructuralSearch.Rules`
`5`	`5`	`{`
`6`		`- public class SubRule : IRule`
	`6`	`+ public class BinarySubRule : IRule`
`7`	`7`	`{`
`8`	`8`	`public SubRuleType Type { get; }`
`9`	`9`
`10`	`10`	`public IRuleParameter Left { get; }`
`11`	`11`
`12`	`12`	`public IRuleParameter Right { get; }`
`13`	`13`
`14`		`- public SubRule(SubRuleType type, IRuleParameter left, IRuleParameter right)`
	`14`	`+ public BinarySubRule(SubRuleType type, IRuleParameter left, IRuleParameter right)`
`15`	`15`	`{`
`16`	`16`	`Type = type;`
`17`	`17`	`Left = left;`