From 7403c18fbc04f3045df1e69b63d7ffd5f04d77db Mon Sep 17 00:00:00 2001
From: Ryo Nihei <nihei.dev@gmail.com>
Date: Fri, 10 Jun 2022 16:41:41 +0900
Subject: Remove the kind field from a node corresponding to an anonymous
 terminal symbol

---
 driver/syntax_error_test.go | 170 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 170 insertions(+)

(limited to 'driver/syntax_error_test.go')

diff --git a/driver/syntax_error_test.go b/driver/syntax_error_test.go
index 1480390..f68f595 100644
--- a/driver/syntax_error_test.go
+++ b/driver/syntax_error_test.go
@@ -2,6 +2,7 @@ package driver
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 	"testing"
 
@@ -153,3 +154,172 @@ c
 		})
 	}
 }
+
+func TestParserWithSyntaxErrorAndExpectedLookahead(t *testing.T) {
+	tests := []struct {
+		caption  string
+		specSrc  string
+		src      string
+		cause    string
+		expected []string
+	}{
+		{
+			caption: "the parser reports an expected lookahead symbol",
+			specSrc: `
+#name test;
+
+s
+    : foo
+    ;
+
+foo
+    : 'foo';
+`,
+			src:   `bar`,
+			cause: `bar`,
+			expected: []string{
+				"foo",
+			},
+		},
+		{
+			caption: "the parser reports expected lookahead symbols",
+			specSrc: `
+#name test;
+
+s
+    : foo
+    | bar
+    ;
+
+foo
+    : 'foo';
+bar
+    : 'bar';
+`,
+			src:   `baz`,
+			cause: `baz`,
+			expected: []string{
+				"foo",
+				"bar",
+			},
+		},
+		{
+			caption: "the parser may report the EOF as an expected lookahead symbol",
+			specSrc: `
+#name test;
+
+s
+    : foo
+    ;
+
+foo
+    : 'foo';
+`,
+			src:   `foobar`,
+			cause: `bar`,
+			expected: []string{
+				"<eof>",
+			},
+		},
+		{
+			caption: "the parser may report the EOF and others as expected lookahead symbols",
+			specSrc: `
+#name test;
+
+s
+    : foo
+    |
+    ;
+
+foo
+    : 'foo';
+`,
+			src:   `bar`,
+			cause: `bar`,
+			expected: []string{
+				"foo",
+				"<eof>",
+			},
+		},
+		{
+			caption: "when an anonymous symbol is expected, an expected symbol list contains an alias of the anonymous symbol",
+			specSrc: `
+#name test;
+
+s
+    : foo 'bar'
+    ;
+
+foo
+    : 'foo';
+`,
+			src:   `foobaz`,
+			cause: `baz`,
+			expected: []string{
+				"bar",
+			},
+		},
+	}
+	for i, tt := range tests {
+		t.Run(fmt.Sprintf("#%v", i), func(t *testing.T) {
+			ast, err := spec.Parse(strings.NewReader(tt.specSrc))
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			b := grammar.GrammarBuilder{
+				AST: ast,
+			}
+			g, err := b.Build()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			gram, _, err := grammar.Compile(g)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			toks, err := NewTokenStream(gram, strings.NewReader(tt.src))
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			p, err := NewParser(toks, NewGrammar(gram))
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = p.Parse()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			synErrs := p.SyntaxErrors()
+			if synErrs == nil {
+				t.Fatalf("expected one syntax error, but it didn't occur")
+			}
+			if len(synErrs) != 1 {
+				t.Fatalf("too many syntax errors: %v errors", len(synErrs))
+			}
+			synErr := synErrs[0]
+			if string(synErr.Token.Lexeme()) != tt.cause {
+				t.Fatalf("unexpected lexeme: want: %v, got: %v", tt.cause, string(synErr.Token.Lexeme()))
+			}
+			if len(synErr.ExpectedTerminals) != len(tt.expected) {
+				t.Fatalf("unexpected lookahead symbols: want: %v, got: %v", tt.expected, synErr.ExpectedTerminals)
+			}
+			sort.Slice(tt.expected, func(i, j int) bool {
+				return tt.expected[i] < tt.expected[j]
+			})
+			sort.Slice(synErr.ExpectedTerminals, func(i, j int) bool {
+				return synErr.ExpectedTerminals[i] < synErr.ExpectedTerminals[j]
+			})
+			for i, e := range tt.expected {
+				if synErr.ExpectedTerminals[i] != e {
+					t.Errorf("unexpected lookahead symbol: want: %v, got: %v", e, synErr.ExpectedTerminals[i])
+				}
+			}
+		})
+	}
+}
-- 
cgit v1.2.3