Merge pull request #521 from b3b00/bugfix/oeration-implicit-operators

b3b00 · web-flow · commit ca859c679f76 · 2024-12-23T17:21:14.000+01:00
Bugfix/oeration implicit operators
diff --git a/src/samples/SimpleExpressionParser/SimpleExpressionParser.cs b/src/samples/SimpleExpressionParser/SimpleExpressionParser.cs
@@ -15,6 +15,7 @@ public class SimpleExpressionParser
         
         [Operation((int) ExpressionToken.PLUS, Affix.InFix, Associativity.Right, 10)]
         [Operation("MINUS", Affix.InFix, Associativity.Left, 10)]
+        [NodeName("addition_or_substraction")]
         public double BinaryTermExpression(double left, Token<ExpressionToken> operation, double right)
         {
             double result = 0;
@@ -61,11 +62,13 @@ public double BinaryFactorExpression(double left, Token<ExpressionToken> operati
 
 
         [Prefix((int) ExpressionToken.MINUS,  Associativity.Right, 100)]
+        [NodeName("minus")]
         public double PreFixExpression(Token<ExpressionToken> operation, double value)
         {
             return -value;
         }
 
+        [NodeName("factorial")]
         [Postfix((int) ExpressionToken.FACTORIAL, Associativity.Right, 100)]
         public double PostFixExpression(double value, Token<ExpressionToken> operation)
         {
@@ -76,29 +79,29 @@ public double PostFixExpression(double value, Token<ExpressionToken> operation)
 
         [Operand]
         [Production("operand : primary_value")]
-        [NodeName("double")]
+        [NodeName("op_prim")]
         public double OperandValue(double value)
         {
             return value;
         }
 
 
         [Production("primary_value : DOUBLE")]
-        [NodeName("double")]
+        [NodeName("prim_double")]
         public double OperandDouble(Token<ExpressionToken> value)
         {
             return value.DoubleValue;
         }
         
         [Production("primary_value : INT")]
-        [NodeName("integer")]
+        [NodeName("prim_int")]
         public double OperandInt(Token<ExpressionToken> value)
         {
             return value.DoubleValue;
         }
 
         [Production("primary_value : LPAREN SimpleExpressionParser_expressions RPAREN")]
-        [NodeName("group")]
+        [NodeName("prim_group")]
         public double OperandParens(Token<ExpressionToken> lparen, double value, Token<ExpressionToken> rparen)
         {
             return value;
diff --git a/src/sly/parser/fluent/FluentEBNFParserBuilder.cs b/src/sly/parser/fluent/FluentEBNFParserBuilder.cs
@@ -368,4 +368,13 @@ public IFluentEbnfParserBuilder<IN, OUT> Named(string name)
         }
         return this;
     }
+
+    public IFluentEbnfParserBuilder<IN, OUT> WithSubNodeNamed(params string[] subNodeNames)
+    {
+        if (_currentRule != null)
+        {
+            _currentRule.SubNodeNames = subNodeNames;
+        }
+        return this;
+    }
 }
diff --git a/src/sly/parser/fluent/IFluentEbnfParserBuilder.cs b/src/sly/parser/fluent/IFluentEbnfParserBuilder.cs
@@ -7,6 +7,8 @@ namespace sly.parser.generator;
 public interface IFluentEbnfRuleBuilder<IN, OUT> : IFluentEbnfParserBuilder<IN, OUT> where IN : struct
 {
     public IFluentEbnfParserBuilder<IN, OUT> Named(string name);
+    
+    public IFluentEbnfParserBuilder<IN, OUT> WithSubNodeNamed(params string[] subNodeNames);
 }
 
 public interface IFluentEbnfParserBuilder<IN,OUT> where IN : struct
diff --git a/src/sly/parser/generator/EBNFParserBuilder.cs b/src/sly/parser/generator/EBNFParserBuilder.cs
@@ -167,7 +167,6 @@ protected virtual ParserConfiguration<IN, OUT> ExtractEbnfParserConfiguration(Ty
 
                 var nodeNames = (NodeNameAttribute[])m.GetCustomAttributes(typeof(NodeNameAttribute), true);
                 string nodeName = nodeNames != null && nodeNames.Any() ? nodeNames[0].Name : null;
-                
                 var subNodeNamesAttributes = (SubNodeNamesAttribute[])m.GetCustomAttributes(typeof(SubNodeNamesAttribute), true);
                 string[] subNodeNames = subNodeNamesAttributes != null && subNodeNamesAttributes.Any() ? subNodeNamesAttributes[0].Names : null;
                 
@@ -178,6 +177,7 @@ protected virtual ParserConfiguration<IN, OUT> ExtractEbnfParserConfiguration(Ty
                     if (!parseResult.IsError)
                     {
                         var rule = (Rule<IN, OUT>)parseResult.Result;
+                        rule.ForcedName = nodeName != null;
                         rule.NodeName = nodeName;
                         rule.SubNodeNames = subNodeNames;
                         rule.RuleString = ruleString;
diff --git a/src/sly/parser/generator/ExpressionRulesGenerator.cs b/src/sly/parser/generator/ExpressionRulesGenerator.cs
@@ -256,6 +256,7 @@ private void GenerateExpressionParser(ParserConfiguration<IN, OUT> configuration
             rule.IsByPassRule = true;
             rule.IsExpressionRule = true;
             rule.ExpressionAffix = Affix.NotOperator;
+            rule.SetLambdaVisitor((args) => (OUT)args[0]);
             configuration.NonTerminals[entrypoint.Name] = entrypoint;
             entrypoint.Rules.Add(rule);
         }
@@ -283,7 +284,9 @@ private NonTerminal<IN, OUT> BuildPrecedenceNonTerminal(string name, string next
                 {
                     ExpressionAffix = Affix.InFix,
                     IsExpressionRule = true,
-                    NonTerminalName = name
+                    NonTerminalName = name,
+                    NodeName = InFixOps[0].NodeName,
+                    ForcedName = !string.IsNullOrEmpty(InFixOps[0].NodeName)
                 };
 
                 rule.Clauses.Add(new NonTerminalClause<IN, OUT>(nextName));
@@ -295,7 +298,8 @@ private NonTerminal<IN, OUT> BuildPrecedenceNonTerminal(string name, string next
                     rule.SetVisitor(x);
                     rule.IsExpressionRule = true;
                     rule.IsInfixExpressionRule = true;
-
+                    rule.NodeName = x.NodeName;
+                    rule.ForcedName = !string.IsNullOrEmpty(x.NodeName);
                 });
                 nonTerminal.Rules.Add(rule);
                 if (isLastLevel)
@@ -306,7 +310,7 @@ private NonTerminal<IN, OUT> BuildPrecedenceNonTerminal(string name, string next
                         ExpressionAffix = Affix.NotOperator,
                         IsExpressionRule = true,
                         NonTerminalName = name,
-                        IsByPassRule = true
+                        IsByPassRule = true,
                     };
 
                     rule2.Clauses.Add(new NonTerminalClause<IN, OUT>(nextName));
@@ -336,7 +340,9 @@ private NonTerminal<IN, OUT> BuildPrecedenceNonTerminal(string name, string next
                 var rule = new Rule<IN, OUT>
                 {
                     ExpressionAffix = Affix.PreFix,
-                    IsExpressionRule = true
+                    IsExpressionRule = true,
+                    NodeName = PreFixOps[0].NodeName,
+                    ForcedName = !string.IsNullOrEmpty(PreFixOps[0].NodeName)
                 };
 
                 rule.Clauses.Add(PreFixClauses.Count == 1 ? PreFixClauses[0] : new ChoiceClause<IN, OUT>(PreFixClauses));
@@ -365,7 +371,9 @@ private NonTerminal<IN, OUT> BuildPrecedenceNonTerminal(string name, string next
                 var rule = new Rule<IN, OUT>
                 {
                     ExpressionAffix = Affix.PostFix,
-                    IsExpressionRule = true
+                    IsExpressionRule = true,
+                    NodeName = PostFixOps[0].NodeName,
+                    ForcedName = !string.IsNullOrEmpty(PostFixOps[0].NodeName)
                 };
 
                 rule.Clauses.Add(new NonTerminalClause<IN, OUT>(nextName));
diff --git a/src/sly/parser/generator/OperationMetaData.cs b/src/sly/parser/generator/OperationMetaData.cs
@@ -30,7 +30,7 @@ public OperationMetaData(int precedence, Associativity assoc, Func<object[],OUT>
         {
             Precedence = precedence;
             Associativity = assoc;
-            VisitorLambda = lambda;
+            LambdaVisitor = lambda;
             OperatorToken = oper;
             Affix = affix;
             NodeName = nodeName;
@@ -40,7 +40,7 @@ public OperationMetaData(int precedence, Associativity assoc, Func<object[],OUT>
         {
             Precedence = precedence;
             Associativity = assoc;
-            VisitorLambda = lambda;
+            LambdaVisitor = lambda;
             ExplicitOperatorToken = oper;
             Affix = affix;
             NodeName = nodeName;
@@ -52,11 +52,11 @@ public OperationMetaData(int precedence, Associativity assoc, Func<object[],OUT>
 
         public MethodInfo VisitorMethod { get; set; }
         
-        public Func<object[],OUT> VisitorLambda { get; set; }  
+        public Func<object[],OUT> LambdaVisitor { get; set; }  
 
         public IN OperatorToken { get; set; }
 
-        public string Operatorkey => NodeName ?? (IsExplicitOperatorToken ? ExplicitOperatorToken : OperatorToken.ToString());
+        public string Operatorkey => (IsExplicitOperatorToken ? ExplicitOperatorToken : OperatorToken.ToString());
 
         public Affix Affix { get; set; }
         
diff --git a/src/sly/parser/generator/ParserBuilder.cs b/src/sly/parser/generator/ParserBuilder.cs
@@ -471,7 +471,7 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
         {
             if (!rule.IsExpressionRule)
             {
-                var visitor = rule.GetVisitor();
+                var visitor = rule.GetVisitorMethod();
 
                 var returnInfo = visitor.ReturnParameter;
                 var expectedReturn = typeof(OUT);
diff --git a/src/sly/parser/generator/visitor/EBNFSyntaxTreeVisitor.cs b/src/sly/parser/generator/visitor/EBNFSyntaxTreeVisitor.cs
@@ -86,7 +86,7 @@ private SyntaxVisitorResult<IN, OUT> Visit(OptionSyntaxNode<IN, OUT> node, objec
         private SyntaxVisitorResult<IN, OUT> Visit(SyntaxNode<IN, OUT> node, object context = null)
         {
             var result = SyntaxVisitorResult<IN, OUT>.NoneResult();
-            if (node.LambdaVisitor != null || node.Visitor != null || node.IsByPassNode)
+            if (!node .IsByPassNode && (node.LambdaVisitor != null || node.Visitor != null ))
             {
                 int parametersArrayLength = node.Children.Count + (context is NoContext ? 0 : 1); 
                 var parameters = new object[parametersArrayLength];
@@ -176,6 +176,12 @@ private SyntaxVisitorResult<IN, OUT> Visit(SyntaxNode<IN, OUT> node, object cont
                     }
                 }
             }
+            else if (node.IsByPassNode)
+            {
+                var child = node.Children[0];
+                var v = Visit(child, context);
+                return v;
+            }
 
             return result;
         }
diff --git a/src/sly/parser/parser/llparser/bnf/RecursiveDescentSyntaxParser.Expressions.cs b/src/sly/parser/parser/llparser/bnf/RecursiveDescentSyntaxParser.Expressions.cs
@@ -27,37 +27,38 @@ protected SyntaxNode<IN, OUT> ManageExpressionRules(Rule<IN, OUT> rule, SyntaxNo
                             case 2 when node.ExpressionAffix == Affix.PreFix:
                                 operatorIndex = 0;
                                 break;
-                            case 2:
+                            case 2 when node.ExpressionAffix == Affix.PostFix:
                             {
-                                if (node.ExpressionAffix == Affix.PostFix) operatorIndex = 1;
+                                operatorIndex = 1;
                                 break;
                             }
                         }
 
                         if (operatorIndex >= 0 && node.Children[operatorIndex] is SyntaxLeaf<IN, OUT> operatorNode)
                         {
-                            var visitor = rule.GetVisitor(operatorNode.Token.TokenID);
-                            if (visitor != null)
-                            {
-                                node.Visitor = visitor;
-                                node.Operation = rule.GetOperation(operatorNode.Token.TokenID);
-                            }
-                            var lmabdaVisitor = rule.getLambdaVisitor(operatorNode.Token.TokenID);
-                            if (lmabdaVisitor != null)
+                            var token = operatorNode.Token;
+                            string key =  (token.IsExplicit ? $"'{token.Value}'" : token.TokenID.ToString());
+                            var operation = rule.GetOperation(key);
+                            if (operation != null)
                             {
-                                node.LambdaVisitor = lmabdaVisitor;
-                                node.Operation = rule.GetOperation(operatorNode.Token.TokenID);
+                                node.Visitor = operation.VisitorMethod;
+                                node.LambdaVisitor = operation.LambdaVisitor;
+                                node.Operation = operation;
+                                if (!string.IsNullOrEmpty(operation.NodeName))
+                                {
+                                    node.Name = operation.NodeName;
+                                }
                             }
                         }
-
                         break;
                     }
                     case false:
-                        node.LambdaVisitor = rule.getLambdaVisitor();
-                        node.Visitor = rule.GetVisitor();
+                    {
+                        node.LambdaVisitor = rule.getLambdaVisitor(null);
+                        node.Visitor = rule.GetVisitorMethod(null);
                         break;
+                    }
                 }
-    
                 return node;
             }
     
diff --git a/src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.Expressions.cs b/src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.Expressions.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using sly.lexer;
 using sly.parser;
+using sly.parser.generator;
 using sly.parser.syntax.grammar;
 using sly.parser.syntax.tree;
 
@@ -14,6 +15,7 @@ public virtual SyntaxParseResult<IN, OUT> ParseInfixExpressionRule(IList<Token<I
         int position,
         string nonTerminalName, SyntaxParsingContext<IN, OUT> parsingContext)
     {
+        OperationMetaData<IN,OUT> operation = null;
         var currentPosition = position;
         var children = new List<ISyntaxNode<IN, OUT>>();
         if (!tokens[position].IsEOS && rule.Match(tokens, position, Configuration) && rule.Clauses != null &&
@@ -34,6 +36,7 @@ public virtual SyntaxParseResult<IN, OUT> ParseInfixExpressionRule(IList<Token<I
             currentPosition = firstResult.EndingPosition;
             var second = rule.Clauses[1];
             SyntaxParseResult<IN, OUT> secondResult = null;
+            
             switch (second)
             {
                 case ChoiceClause<IN, OUT> secondChoice:
@@ -90,7 +93,7 @@ public virtual SyntaxParseResult<IN, OUT> ParseInfixExpressionRule(IList<Token<I
                     children.Add(secondResult.Root);
                     children.Add(thirdResult.Root);
                     currentPosition = thirdResult.EndingPosition;
-                    var finalNode = new SyntaxNode<IN, OUT>(nonTerminalName, children);
+                    var finalNode = new SyntaxNode<IN, OUT>(rule.NodeName ?? nonTerminalName, children);
                     finalNode.ExpressionAffix = rule.ExpressionAffix;
                     finalNode = ManageExpressionRules(rule, finalNode);
                     var finalResult = new SyntaxParseResult<IN, OUT>();
diff --git a/src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.Option.cs b/src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.Option.cs
@@ -65,7 +65,7 @@ public SyntaxParseResult<IN, OUT> ParseOption(IList<Token<IN>> tokens, OptionCla
                         {
                             IsError = false,
                             Root = new OptionSyntaxNode<IN, OUT>(rule.NonTerminalName, new List<ISyntaxNode<IN, OUT>>(),
-                                rule.GetVisitor()),
+                                rule.GetVisitorMethod()),
                             EndingPosition = position
                         };
                     }
@@ -79,7 +79,7 @@ public SyntaxParseResult<IN, OUT> ParseOption(IList<Token<IN>> tokens, OptionCla
                     var children = new List<ISyntaxNode<IN, OUT>> { innerResult.Root };
                     if (innerResult.IsError) children.Clear();
                     result.Root = new OptionSyntaxNode<IN, OUT>(rule.NonTerminalName, children,
-                        rule.GetVisitor());
+                        rule.GetVisitorMethod());
                     (result.Root as OptionSyntaxNode<IN, OUT>).IsGroupOption = clause.IsGroupOption;
                     result.EndingPosition = position;
                     break;
@@ -90,7 +90,7 @@ public SyntaxParseResult<IN, OUT> ParseOption(IList<Token<IN>> tokens, OptionCla
         {
             var children = new List<ISyntaxNode<IN, OUT>> { innerResult.Root };
             result.Root =
-                new OptionSyntaxNode<IN, OUT>(rule.NonTerminalName, children, rule.GetVisitor());
+                new OptionSyntaxNode<IN, OUT>(rule.NonTerminalName, children, rule.GetVisitorMethod());
             result.EndingPosition = innerResult.EndingPosition;
             result.HasByPassNodes = innerResult.HasByPassNodes;
         }
diff --git a/src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.cs b/src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.cs
@@ -162,6 +162,7 @@ public override SyntaxParseResult<IN, OUT> Parse(IList<Token<IN>> tokens, Rule<I
                         }
                     }
                     node = new SyntaxNode<IN, OUT>( nonTerminalName,  children);
+                    node.ForcedName = rule.ForcedName;
                     node.Name = string.IsNullOrEmpty(rule.NodeName) ? nonTerminalName : rule.NodeName;
                     node.ExpressionAffix = rule.ExpressionAffix;
                     node = ManageExpressionRules(rule, node);
diff --git a/src/sly/parser/syntax/grammar/Rule.cs b/src/sly/parser/syntax/grammar/Rule.cs
diff --git a/src/sly/parser/syntax/tree/SyntaxNode.cs b/src/sly/parser/syntax/tree/SyntaxNode.cs
diff --git a/tests/ParserTests/ExpressionGeneratorTests.cs b/tests/ParserTests/ExpressionGeneratorTests.cs
diff --git a/tests/ParserTests/FluentTests.cs b/tests/ParserTests/FluentTests.cs

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ public class SimpleExpressionParser`
`15`	`15`
`16`	`16`	`[Operation((int) ExpressionToken.PLUS, Affix.InFix, Associativity.Right, 10)]`
`17`	`17`	`[Operation("MINUS", Affix.InFix, Associativity.Left, 10)]`
	`18`	`+ [NodeName("addition_or_substraction")]`
`18`	`19`	`public double BinaryTermExpression(double left, Token<ExpressionToken> operation, double right)`
`19`	`20`	`{`
`20`	`21`	`double result = 0;`
`@@ -61,11 +62,13 @@ public double BinaryFactorExpression(double left, Token<ExpressionToken> operati`
`61`	`62`
`62`	`63`
`63`	`64`	`[Prefix((int) ExpressionToken.MINUS, Associativity.Right, 100)]`
	`65`	`+ [NodeName("minus")]`
`64`	`66`	`public double PreFixExpression(Token<ExpressionToken> operation, double value)`
`65`	`67`	`{`
`66`	`68`	`return -value;`
`67`	`69`	`}`
`68`	`70`
	`71`	`+ [NodeName("factorial")]`
`69`	`72`	`[Postfix((int) ExpressionToken.FACTORIAL, Associativity.Right, 100)]`
`70`	`73`	`public double PostFixExpression(double value, Token<ExpressionToken> operation)`
`71`	`74`	`{`
`@@ -76,29 +79,29 @@ public double PostFixExpression(double value, Token<ExpressionToken> operation)`
`76`	`79`
`77`	`80`	`[Operand]`
`78`	`81`	`[Production("operand : primary_value")]`
`79`		`- [NodeName("double")]`
	`82`	`+ [NodeName("op_prim")]`
`80`	`83`	`public double OperandValue(double value)`
`81`	`84`	`{`
`82`	`85`	`return value;`
`83`	`86`	`}`
`84`	`87`
`85`	`88`
`86`	`89`	`[Production("primary_value : DOUBLE")]`
`87`		`- [NodeName("double")]`
	`90`	`+ [NodeName("prim_double")]`
`88`	`91`	`public double OperandDouble(Token<ExpressionToken> value)`
`89`	`92`	`{`
`90`	`93`	`return value.DoubleValue;`
`91`	`94`	`}`
`92`	`95`
`93`	`96`	`[Production("primary_value : INT")]`
`94`		`- [NodeName("integer")]`
	`97`	`+ [NodeName("prim_int")]`
`95`	`98`	`public double OperandInt(Token<ExpressionToken> value)`
`96`	`99`	`{`
`97`	`100`	`return value.DoubleValue;`
`98`	`101`	`}`
`99`	`102`
`100`	`103`	`[Production("primary_value : LPAREN SimpleExpressionParser_expressions RPAREN")]`
`101`		`- [NodeName("group")]`
	`104`	`+ [NodeName("prim_group")]`
`102`	`105`	`public double OperandParens(Token<ExpressionToken> lparen, double value, Token<ExpressionToken> rparen)`
`103`	`106`	`{`
`104`	`107`	`return value;`
Original file line number	Diff line number	Diff line change
`@@ -368,4 +368,13 @@ public IFluentEbnfParserBuilder<IN, OUT> Named(string name)`
`368`	`368`	`}`
`369`	`369`	`return this;`
`370`	`370`	`}`
	`371`	`+`
	`372`	`+ public IFluentEbnfParserBuilder<IN, OUT> WithSubNodeNamed(params string[] subNodeNames)`
	`373`	`+ {`
	`374`	`+ if (_currentRule != null)`
	`375`	`+ {`
	`376`	`+ _currentRule.SubNodeNames = subNodeNames;`
	`377`	`+ }`
	`378`	`+ return this;`
	`379`	`+ }`
`371`	`380`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@ namespace sly.parser.generator;`
`7`	`7`	`public interface IFluentEbnfRuleBuilder<IN, OUT> : IFluentEbnfParserBuilder<IN, OUT> where IN : struct`
`8`	`8`	`{`
`9`	`9`	`public IFluentEbnfParserBuilder<IN, OUT> Named(string name);`
	`10`	`+`
	`11`	`+ public IFluentEbnfParserBuilder<IN, OUT> WithSubNodeNamed(params string[] subNodeNames);`
`10`	`12`	`}`
`11`	`13`
`12`	`14`	`public interface IFluentEbnfParserBuilder<IN,OUT> where IN : struct`
Original file line number	Diff line number	Diff line change
`@@ -471,7 +471,7 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN`
`471`	`471`	`{`
`472`	`472`	`if (!rule.IsExpressionRule)`
`473`	`473`	`{`
`474`		`- var visitor = rule.GetVisitor();`
	`474`	`+ var visitor = rule.GetVisitorMethod();`
`475`	`475`
`476`	`476`	`var returnInfo = visitor.ReturnParameter;`
`477`	`477`	`var expectedReturn = typeof(OUT);`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ private SyntaxVisitorResult<IN, OUT> Visit(OptionSyntaxNode<IN, OUT> node, objec`
`86`	`86`	`private SyntaxVisitorResult<IN, OUT> Visit(SyntaxNode<IN, OUT> node, object context = null)`
`87`	`87`	`{`
`88`	`88`	`var result = SyntaxVisitorResult<IN, OUT>.NoneResult();`
`89`		`- if (node.LambdaVisitor != null \|\| node.Visitor != null \|\| node.IsByPassNode)`
	`89`	`+ if (!node .IsByPassNode && (node.LambdaVisitor != null \|\| node.Visitor != null ))`
`90`	`90`	`{`
`91`	`91`	`int parametersArrayLength = node.Children.Count + (context is NoContext ? 0 : 1);`
`92`	`92`	`var parameters = new object[parametersArrayLength];`
`@@ -176,6 +176,12 @@ private SyntaxVisitorResult<IN, OUT> Visit(SyntaxNode<IN, OUT> node, object cont`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`	`}`
	`179`	`+ else if (node.IsByPassNode)`
	`180`	`+ {`
	`181`	`+ var child = node.Children[0];`
	`182`	`+ var v = Visit(child, context);`
	`183`	`+ return v;`
	`184`	`+ }`
`179`	`185`
`180`	`186`	`return result;`
`181`	`187`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,37 +27,38 @@ protected SyntaxNode<IN, OUT> ManageExpressionRules(Rule<IN, OUT> rule, SyntaxNo`
`27`	`27`	`case 2 when node.ExpressionAffix == Affix.PreFix:`
`28`	`28`	`operatorIndex = 0;`
`29`	`29`	`break;`
`30`		`- case 2:`
	`30`	`+ case 2 when node.ExpressionAffix == Affix.PostFix:`
`31`	`31`	`{`
`32`		`- if (node.ExpressionAffix == Affix.PostFix) operatorIndex = 1;`
	`32`	`+ operatorIndex = 1;`
`33`	`33`	`break;`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`if (operatorIndex >= 0 && node.Children[operatorIndex] is SyntaxLeaf<IN, OUT> operatorNode)`
`38`	`38`	`{`
`39`		`- var visitor = rule.GetVisitor(operatorNode.Token.TokenID);`
`40`		`- if (visitor != null)`
`41`		`- {`
`42`		`- node.Visitor = visitor;`
`43`		`- node.Operation = rule.GetOperation(operatorNode.Token.TokenID);`
`44`		`- }`
`45`		`- var lmabdaVisitor = rule.getLambdaVisitor(operatorNode.Token.TokenID);`
`46`		`- if (lmabdaVisitor != null)`
	`39`	`+ var token = operatorNode.Token;`
	`40`	`+ string key = (token.IsExplicit ? $"'{token.Value}'" : token.TokenID.ToString());`
	`41`	`+ var operation = rule.GetOperation(key);`
	`42`	`+ if (operation != null)`
`47`	`43`	`{`
`48`		`- node.LambdaVisitor = lmabdaVisitor;`
`49`		`- node.Operation = rule.GetOperation(operatorNode.Token.TokenID);`
	`44`	`+ node.Visitor = operation.VisitorMethod;`
	`45`	`+ node.LambdaVisitor = operation.LambdaVisitor;`
	`46`	`+ node.Operation = operation;`
	`47`	`+ if (!string.IsNullOrEmpty(operation.NodeName))`
	`48`	`+ {`
	`49`	`+ node.Name = operation.NodeName;`
	`50`	`+ }`
`50`	`51`	`}`
`51`	`52`	`}`
`52`		`-`
`53`	`53`	`break;`
`54`	`54`	`}`
`55`	`55`	`case false:`
`56`		`- node.LambdaVisitor = rule.getLambdaVisitor();`
`57`		`- node.Visitor = rule.GetVisitor();`
	`56`	`+ {`
	`57`	`+ node.LambdaVisitor = rule.getLambdaVisitor(null);`
	`58`	`+ node.Visitor = rule.GetVisitorMethod(null);`
`58`	`59`	`break;`
	`60`	`+ }`
`59`	`61`	`}`
`60`		`-`
`61`	`62`	`return node;`
`62`	`63`	`}`
`63`	`64`