many node names for same precedence level

Author: b3b00

src/sly/parser/parser/llparser/bnf/RecursiveDescentSyntaxParser.Expressions.cs

@@ -44,7 +44,10 @@ protected SyntaxNode<IN, OUT> ManageExpressionRules(Rule<IN, OUT> rule, SyntaxNo
                                 node.Visitor = operation.VisitorMethod;
                                 node.LambdaVisitor = operation.LambdaVisitor;
                                 node.Operation = operation;
-                                node.Name = operation.NodeName;
+                                if (!string.IsNullOrEmpty(operation.NodeName))
+                                {
+                                    node.Name = operation.NodeName;
+                                }
                             }
                         }
                         break;

src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.Expressions.cs

@@ -37,14 +37,6 @@ public virtual SyntaxParseResult<IN, OUT> ParseInfixExpressionRule(IList<Token<I
             var second = rule.Clauses[1];
             SyntaxParseResult<IN, OUT> secondResult = null;
 
-            var op = tokens[position];
-            string key = op.TokenID.ToString();
-            if (op.IsExplicit)
-            {
-                key = op.Value.ToString();
-            }
-            operation = rule.GetOperation(key);
-            
             switch (second)
             {
                 case ChoiceClause<IN, OUT> secondChoice:

src/sly/parser/syntax/grammar/Rule.cs

@@ -25,6 +25,8 @@ public Rule()
 
         public string[] SubNodeNames { get; set; } = null;
 
+        private Dictionary<string,string> NodeNamesMap { get; set; } = new Dictionary<string, string>();
+        
         public bool IsByPassRule { get; set; } = false;
 
         // visitors for operation rules
@@ -197,6 +199,7 @@ public void SetVisitor(Func<object[],OUT> visitorLambda)
 
         public void SetVisitor(OperationMetaData<IN, OUT> operation)
         {
+            NodeNamesMap[operation.Operatorkey] = operation.NodeName;
             if (operation.VisitorMethod != null)
                 VisitorMethodsForOperation[operation.Operatorkey] = operation;
             else if (operation.LambdaVisitor != null)

tests/ParserTests/ExpressionGeneratorTests.cs

@@ -9,6 +9,7 @@
 using Xunit;
 using ParserTests.Issue184;
 using sly.parser.generator.visitor;
+using sly.parser.syntax.tree;
 using ExpressionToken = expressionparser.ExpressionToken;
 
 namespace ParserTests
@@ -26,6 +27,32 @@ public double BinaryTermExpression(double left, Token<ExpressionToken> operation
         }
 
     }
+
+    public class PrefixOperation
+    {
+        [Prefix("'##'",Associativity.Left,10)]
+        [NodeName("hash-hash")]
+        public string prefixHashHash(Token<SimpleExpressionToken> token, string operand)
+        {
+            return $"{token.Value}::{operand}";
+        }
+        
+        [Prefix("'@@'",Associativity.Left,10)]
+        [NodeName("at-at")]
+        public string prefixAtAt(Token<SimpleExpressionToken> token, string operand)
+        {
+            return $"{token.Value}::{operand}";
+        }
+        
+        
+
+        [Operand]
+        [Production("testOperand: INT")]
+        public string Operand(Token<SimpleExpressionToken> token)
+        {
+            return token.Value;
+        }
+    }
 
     public class ExpressionGeneratorExplicitOperatorAsNames
     {
@@ -48,6 +75,7 @@ public double BinaryTermExpression(double left, Token<SimpleExpressionToken> ope
         }
 
         [Prefix((int) SimpleExpressionToken.MINUS,  Associativity.Right, 100)]
+        [NodeName("hash-hash")]
         public double PreFixExpression(Token<SimpleExpressionToken> operation, double value)
         {
             return -value;
@@ -430,5 +458,42 @@ public void TestExplicitOperatorAsNames()
             Check.That(result).IsOkParsing();
             Check.That(result.Result).IsEqualTo(-1+2*(5+6)-4);
         }
+
+        [Fact]
+        public void TestPrefix()
+        {
+            StartingRule = $"{nameof(PrefixOperation)}_expressions";
+            var parserInstance = new PrefixOperation();
+            var builder = new ParserBuilder<SimpleExpressionToken, string>();
+            var buildResult = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, StartingRule);
+            Check.That(buildResult).IsOk();
+            var parser = buildResult.Result;
+            
+            var result = parser.Parse("## 42");
+            Check.That(result).IsOkParsing();
+            Check.That(result.Result).IsEqualTo("##::42");
+            var tree = result.SyntaxTree;
+            var syntaxTree = tree as SyntaxNode<SimpleExpressionToken, string>;
+            Check.That(syntaxTree).IsNotNull();
+            Check.That(syntaxTree.Children).CountIs(1);
+            Check.That(syntaxTree.Name).IsEqualTo($"{nameof(PrefixOperation)}_expressions");
+            var child = syntaxTree.Children[0] as SyntaxNode<SimpleExpressionToken, string>;
+            Check.That(child).IsNotNull();
+            Check.That(child.Name).IsEqualTo("hash-hash");
+            Check.That(child.Children).CountIs(2);
+            
+            result = parser.Parse("@@ 42");
+            Check.That(result).IsOkParsing();
+            Check.That(result.Result).IsEqualTo("@@::42");
+            tree = result.SyntaxTree;
+            syntaxTree = tree as SyntaxNode<SimpleExpressionToken, string>;
+            Check.That(syntaxTree).IsNotNull();
+            Check.That(syntaxTree.Children).CountIs(1);
+            Check.That(syntaxTree.Name).IsEqualTo($"{nameof(PrefixOperation)}_expressions");
+            child = syntaxTree.Children[0] as SyntaxNode<SimpleExpressionToken, string>;
+            Check.That(child).IsNotNull();
+            Check.That(child.Name).IsEqualTo("at-at");
+            Check.That(child.Children).CountIs(2);
+        }
     }
 }