fix non terminal alternate option clause.

b3b00 · Oct 11, 2024 · 3ce30f0 · 3ce30f0
1 parent be74c8d
commit 3ce30f0
Show file tree

Hide file tree

Showing 16 changed files with 99 additions and 55 deletions.
diff --git a/src/samples/indented/IndentedParser2.cs b/src/samples/indented/IndentedParser2.cs
@@ -30,7 +30,7 @@ public Ast integer(Token<IndentedLangLexer2> tok)
         [Production("statement: [set|ifthenelse]? EOL[d]")]
         public Ast Statement(ValueOption<Ast> stat)
         {
-            return stat.Match(
+            return stat.Match<Ast>(
                 x => x as Statement,
                 () => new EmptyLine()
             );

diff --git a/src/sly/parser/generator/visitor/ConcreteSyntaxTreeWalker.cs b/src/sly/parser/generator/visitor/ConcreteSyntaxTreeWalker.cs
@@ -46,10 +46,6 @@ public OUT Visit(ISyntaxNode<IN> n)
                     return Visit(node);
                 case SyntaxNode<IN> node:
                     return Visit(node);
-                case SyntaxEpsilon<IN> epsilon:
-                {
-                    return Visitor.VisitEpsilon();
-                }
                 default:
                     return Visitor.VisitLeaf(new Token<IN>() {TokenID = default(IN),SpanValue="NULL".ToCharArray()});
             }

diff --git a/src/sly/parser/generator/visitor/EBNFSyntaxTreeVisitor.cs b/src/sly/parser/generator/visitor/EBNFSyntaxTreeVisitor.cs
@@ -29,8 +29,6 @@ protected override SyntaxVisitorResult<IN, OUT> Visit(ISyntaxNode<IN> n, object
                     return Visit(node, context);
                 case SyntaxNode<IN> node:
                     return Visit(node, context);
-                case SyntaxEpsilon<IN> epsilon:
-                    return SyntaxVisitorResult<IN, OUT>.Epsilon();
                 default:
                     return null;
             }
@@ -74,8 +72,6 @@ private SyntaxVisitorResult<IN, OUT> Visit(OptionSyntaxNode<IN> node, object con
             var innerResult = Visit(child, context);
             switch (child)
             {
-                case SyntaxEpsilon<IN> epsilon: 
-                    return SyntaxVisitorResult<IN, OUT>.NewOptionNone();
                 case SyntaxLeaf<IN> leaf:
                     return SyntaxVisitorResult<IN, OUT>.NewToken(leaf.Token);
                 case GroupSyntaxNode<IN> group:
@@ -131,10 +127,6 @@ private SyntaxVisitorResult<IN, OUT> Visit(SyntaxNode<IN> node, object context =
                     {
                         args.Add(v.GroupListResult);
                     }
-                    else if (v.IsEpsilon)
-                    {
-                        args.Add(default(OUT));
-                    }
                 }
 
                 if (node.IsByPassNode)

diff --git a/src/sly/parser/generator/visitor/SyntaxTreeVisitor.cs b/src/sly/parser/generator/visitor/SyntaxTreeVisitor.cs
@@ -128,12 +128,6 @@ public static SyntaxVisitorResult<IN, OUT> NoneResult()
             return res;
         }
 
-        public static SyntaxVisitorResult<IN, OUT> Epsilon()
-        {
-            var res = new SyntaxVisitorResult<IN, OUT>();
-            res.IsEpsilon = true;
-            return res;
-        }
     }
 
     public class SyntaxTreeVisitor<IN, OUT> where IN : struct

diff --git a/src/sly/parser/parser/ValueOption.cs b/src/sly/parser/parser/ValueOption.cs
@@ -44,7 +44,7 @@ public ValueOption(T value)
         public bool IsNone { get; }
         public bool IsSome => !IsNone;
 
-        public T Match(Func<T, T> some, Func<T> none)
+        public X Match<X>(Func<T, X> some, Func<X> none)
         {
             if (IsSome)
                 return some(Value);

diff --git a/src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.Option.cs b/src/sly/parser/parser/llparser/ebnf/EBNFRecursiveDescentSyntaxParser.Option.cs
@@ -61,10 +61,13 @@ public SyntaxParseResult<IN> ParseOption(IList<Token<IN>> tokens, OptionClause<I
                     }
                     else if (choiceClause.IsNonTerminalChoice)
                     {
-                        result = new SyntaxParseResult<IN>();
-                        result.IsError = false;
-                        result.Root = new SyntaxEpsilon<IN>();
-                        result.EndingPosition = position;
+                        result = new SyntaxParseResult<IN>
+                        {
+                            IsError = false,
+                            Root = new OptionSyntaxNode<IN>(rule.NonTerminalName, new List<ISyntaxNode<IN>>(),
+                                rule.GetVisitor()),
+                            EndingPosition = position
+                        };
                     }
 
                     break;

diff --git a/src/sly/parser/syntax/grammar/ChoiceClause.cs b/src/sly/parser/syntax/grammar/ChoiceClause.cs
@@ -46,6 +46,7 @@ public string Dump()
             return ToString();
         }
 
+        [ExcludeFromCodeCoverage]
         public bool Equals(IClause<T> clause)
         {
             if (clause is ChoiceClause<T> other)
@@ -55,7 +56,8 @@ public bool Equals(IClause<T> clause)
 
             return false;
         }
-
+
+        [ExcludeFromCodeCoverage]
         private bool Equals(ChoiceClause<T> other)
         {
             if (other.Choices.Count != Choices.Count)
@@ -71,6 +73,7 @@ private bool Equals(ChoiceClause<T> other)
             return other.Choices.TrueForAll(x => Choices.Exists(y => y.Equals(x)));
         }
 
+        [ExcludeFromCodeCoverage]
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj)) return false;
@@ -79,6 +82,7 @@ public override bool Equals(object obj)
             return Equals((ChoiceClause<T>)obj);
         }
 
+        [ExcludeFromCodeCoverage]
         public override int GetHashCode()
         {
             return Dump().GetHashCode();

diff --git a/src/sly/parser/syntax/grammar/ClauseSequence.cs b/src/sly/parser/syntax/grammar/ClauseSequence.cs
@@ -36,6 +36,7 @@ public string Dump()
             return Clauses.Select(c => c.Dump()).Aggregate((d1, d2) => d1 + " " + d2);
         }
 
+        [ExcludeFromCodeCoverage]
         public bool Equals(IClause<T> other)
         {
             if (other is ClauseSequence<T> sequence && sequence.Clauses.Count == Clauses.Count)

diff --git a/src/sly/parser/syntax/grammar/GroupClause.cs b/src/sly/parser/syntax/grammar/GroupClause.cs
@@ -43,6 +43,7 @@ public string Dump()
         }
 
 
+        [ExcludeFromCodeCoverage]
         public bool Equals(IClause<T> other)
         {
             if (other is GroupClause<T> group && group.Clauses.Count == Clauses.Count)

diff --git a/src/sly/parser/syntax/grammar/NonTerminalClause.cs b/src/sly/parser/syntax/grammar/NonTerminalClause.cs
@@ -32,6 +32,7 @@ public string Dump()
             return $"{NonTerminalName}(NT)";
         }
 
+        [ExcludeFromCodeCoverage]
         public bool Equals(IClause<T> clause)
         {
             if (clause is NonTerminalClause<T> other)
@@ -42,11 +43,13 @@ public bool Equals(IClause<T> clause)
             return false;
         }
 
+        [ExcludeFromCodeCoverage]
         private bool Equals(NonTerminalClause<T> other)
         {
             return NonTerminalName == other.NonTerminalName && IsGroup == other.IsGroup;
         }
 
+        [ExcludeFromCodeCoverage]
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj)) return false;
@@ -55,6 +58,7 @@ public override bool Equals(object obj)
             return Equals((NonTerminalClause<T>)obj);
         }
 
+        [ExcludeFromCodeCoverage]
         public override int GetHashCode()
         {
             return Dump().GetHashCode();

diff --git a/src/sly/parser/syntax/grammar/OneOrMoreClause.cs b/src/sly/parser/syntax/grammar/OneOrMoreClause.cs
@@ -27,6 +27,7 @@ public override string Dump()
             return Clause.Dump()+"+";
         }
 
+        [ExcludeFromCodeCoverage]
         public override bool Equals(IClause<T> other)
         {
             if (other is OneOrMoreClause<T> otherOneOrMore)

diff --git a/src/sly/parser/syntax/grammar/OptionClause.cs b/src/sly/parser/syntax/grammar/OptionClause.cs
@@ -31,6 +31,7 @@ public string Dump()
             return $"{Clause}?";
         }
 
+        [ExcludeFromCodeCoverage]
         public bool Equals(IClause<T> clause)
         {
             if (clause is OptionClause<T> other)
@@ -39,12 +40,14 @@ public bool Equals(IClause<T> clause)
             }
             return false;
         }
-
+
+        [ExcludeFromCodeCoverage]
         private bool Equals(OptionClause<T> other)
         {
             return Equals(Clause, other.Clause);
         }
 
+        [ExcludeFromCodeCoverage]
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj)) return false;
@@ -53,6 +56,7 @@ public override bool Equals(object obj)
             return Equals((OptionClause<T>)obj);
         }
 
+        [ExcludeFromCodeCoverage]
         public override int GetHashCode()
         {
             return (Clause != null ? Clause.GetHashCode() : 0);

diff --git a/src/sly/parser/syntax/grammar/ZeroOrMoreClause.cs b/src/sly/parser/syntax/grammar/ZeroOrMoreClause.cs
@@ -28,6 +28,7 @@ public override string Dump()
             return t;
         }
 
+        [ExcludeFromCodeCoverage]
         public override bool Equals(IClause<T> other)
         {
             if (other is OneOrMoreClause<T> otherOneOrMore)

diff --git a/src/sly/parser/syntax/tree/OptionSyntaxNode.cs b/src/sly/parser/syntax/tree/OptionSyntaxNode.cs
@@ -6,7 +6,7 @@ namespace sly.parser.syntax.tree
     public class OptionSyntaxNode<IN> : SyntaxNode<IN> where IN : struct
     {
         public bool IsGroupOption { get; set; } = false;
-        
+
         public OptionSyntaxNode(string name, List<ISyntaxNode<IN>> children = null, MethodInfo visitor = null) : base(
             name, children, visitor)
         { }

diff --git a/src/sly/parser/syntax/tree/SyntaxEpsilon.cs b/src/sly/parser/syntax/tree/SyntaxEpsilon.cs
diff --git a/tests/ParserTests/EBNFTests.cs b/tests/ParserTests/EBNFTests.cs
@@ -313,12 +313,12 @@ public string rootOption(Token<GroupTestToken> a, ValueOption<Group<GroupTestTok
                 {
                     var aToken = group.Token("A").Value;
                     builder.Append($";{aToken}");
-                    return null;
+                    return builder.ToString();
                 },
                 () =>
                 {
                     builder.Append($";<none>");
-                    return null;
+                    return builder.ToString();
                 });
             builder.Append(")");
             return builder.ToString();
@@ -413,6 +413,51 @@ public string Choice(Token<OptionTestToken> first, Token<OptionTestToken> next)
         }
     }
 
+
+    public class AlternateChoiceTestOptionNonTerminal
+    {
+        [Production("choice : [ A | B | C] [ B | C]? F?")]
+        public string Choice(string first, ValueOption<string> next, ValueOption<string> final)
+        {
+            StringBuilder builder = new StringBuilder();
+            builder.Append(first);
+
+
+            var v = next.Match(x => x,
+                () => "<none>");
+            builder.Append($",{v}");
+            v = final.Match(x => x,
+                () => "<none>");
+            builder.Append($",{v}");
+
+            return builder.ToString();
+        }
+
+        [Production("A : a")]
+        public string A(Token<OptionTestToken> a)
+        {
+            return a.Value;
+        }
+
+        [Production("B : b")]
+        public string B(Token<OptionTestToken> b)
+        {
+            return b.Value;
+        }
+
+        [Production("C : c")]
+        public string C(Token<OptionTestToken> c)
+        {
+            return c.Value;
+        }
+
+        [Production("F : f")]
+        public string F(Token<OptionTestToken> f)
+        {
+            return f.Value;
+        }
+    }
+
     public class AlternateChoiceTestOptionDiscardedTerminal
     {
         [Production("choice : [ a | b | c] [ b | c] [d]")]
@@ -1209,6 +1254,30 @@ public void TestAlternateChoiceOptionTerminal()
             Check.That(parseResult.Result).IsEqualTo("a,<none>");
         }
 
+        [Fact]
+        public void TestAlternateChoiceOptionNonTerminal()
+        {
+            var startingRule = $"choice";
+            var parserInstance = new AlternateChoiceTestOptionNonTerminal();
+            var builder = new ParserBuilder<OptionTestToken, string>();
+            var builtParser = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, startingRule);
+            Check.That(builtParser.IsError).IsFalse();
+            Check.That(builtParser.Errors).IsEmpty();
+            var parseResult = builtParser.Result.Parse("a b f", "choice");
+            Check.That(parseResult.IsOk).IsTrue();
+            Check.That(parseResult.Result).IsEqualTo("a,b,f");
+            parseResult = builtParser.Result.Parse("a", "choice");
+            Check.That(parseResult.IsOk).IsTrue();
+            Check.That(parseResult.Result).IsEqualTo("a,<none>,<none>");
+            parseResult = builtParser.Result.Parse("a b ", "choice");
+            Check.That(parseResult.IsOk).IsTrue();
+            Check.That(parseResult.Result).IsEqualTo("a,b,<none>");
+            parseResult = builtParser.Result.Parse("a f", "choice");
+            Check.That(parseResult.IsOk).IsTrue();
+            Check.That(parseResult.Result).IsEqualTo("a,<none>,f");
+
+        }
+
         [Fact]
         public void TestAlternateChoiceOptionDiscardedTerminal()
         {