Stop supporting SLR(1) and always use LALR(1)

8 files changed, 60 insertions, 83 deletions

diff --git a/driver/conflict_test.go b/driver/conflict_test.go
index e767e5b..1a1199b 100644
--- a/driver/conflict_test.go
+++ b/driver/conflict_test.go
@@ -499,7 +499,7 @@ assign: '=';
 				t.Fatal(err)
 			}
 
-			cg, err := grammar.Compile(g, grammar.SpecifyClass(grammar.ClassSLR))
+			cg, err := grammar.Compile(g)
 			if err != nil {
 				t.Fatal(err)
 			}
diff --git a/driver/lac_test.go b/driver/lac_test.go
index 3cee765..e612b13 100644
--- a/driver/lac_test.go
+++ b/driver/lac_test.go
@@ -56,7 +56,7 @@ d: 'd';
 		t.Fatal(err)
 	}
 
-	gram, err := grammar.Compile(g, grammar.SpecifyClass(grammar.ClassLALR))
+	gram, err := grammar.Compile(g)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/driver/parser.go b/driver/parser.go
index dbebec3..14e9752 100644
--- a/driver/parser.go
+++ b/driver/parser.go
@@ -5,9 +5,6 @@ import (
 )
 
 type Grammar interface {
-	// Class returns a class of grammar.
-	Class() string
-
 	// InitialState returns the initial state of a parser.
 	InitialState() int
 
@@ -88,7 +85,7 @@ type SyntaxError struct {
 
 type ParserOption func(p *Parser) error
 
-// DisableLAC disables LAC (lookahead correction). When the grammar has the LALR class, LAC is enabled by default.
+// DisableLAC disables LAC (lookahead correction). LAC is enabled by default.
 func DisableLAC() ParserOption {
 	return func(p *Parser) error {
 		p.disableLAC = true
@@ -121,10 +118,6 @@ func NewParser(toks TokenStream, gram Grammar, opts ...ParserOption) (*Parser, e
 		stateStack: &stateStack{},
 	}
 
-	if p.gram.Class() != "lalr" {
-		p.disableLAC = true
-	}
-
 	for _, opt := range opts {
 		err := opt(p)
 		if err != nil {
diff --git a/driver/parser_test.go b/driver/parser_test.go
index dc1c141..65958bc 100644
--- a/driver/parser_test.go
+++ b/driver/parser_test.go
@@ -725,70 +725,63 @@ bar: 'bar';
 		},
 	}
 
-	classes := []grammar.Class{
-		grammar.ClassSLR,
-		grammar.ClassLALR,
-	}
-
 	for i, tt := range tests {
-		for _, class := range classes {
-			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)
-				}
-
-				cg, err := grammar.Compile(g, grammar.SpecifyClass(class))
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				toks, err := NewTokenStream(cg, strings.NewReader(tt.src))
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				gram := NewGrammar(cg)
-				tb := NewDefaultSyntaxTreeBuilder()
-				var opt []ParserOption
-				switch {
-				case tt.ast != nil:
-					opt = append(opt, SemanticAction(NewASTActionSet(gram, tb)))
-				case tt.cst != nil:
-					opt = append(opt, SemanticAction(NewCSTActionSet(gram, tb)))
-				}
-				p, err := NewParser(toks, gram, opt...)
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				err = p.Parse()
-				if err != nil {
-					t.Fatal(err)
-				}
-
-				if !tt.synErr && len(p.SyntaxErrors()) > 0 {
-					for _, synErr := range p.SyntaxErrors() {
-						t.Fatalf("unexpected syntax errors occurred: %v", synErr)
-					}
-				}
-
-				switch {
-				case tt.ast != nil:
-					testTree(t, tb.Tree(), tt.ast)
-				case tt.cst != nil:
-					testTree(t, tb.Tree(), tt.cst)
+		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)
+			}
+
+			cg, err := grammar.Compile(g)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			toks, err := NewTokenStream(cg, strings.NewReader(tt.src))
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			gram := NewGrammar(cg)
+			tb := NewDefaultSyntaxTreeBuilder()
+			var opt []ParserOption
+			switch {
+			case tt.ast != nil:
+				opt = append(opt, SemanticAction(NewASTActionSet(gram, tb)))
+			case tt.cst != nil:
+				opt = append(opt, SemanticAction(NewCSTActionSet(gram, tb)))
+			}
+			p, err := NewParser(toks, gram, opt...)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			err = p.Parse()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if !tt.synErr && len(p.SyntaxErrors()) > 0 {
+				for _, synErr := range p.SyntaxErrors() {
+					t.Fatalf("unexpected syntax errors occurred: %v", synErr)
 				}
-			})
-		}
+			}
+
+			switch {
+			case tt.ast != nil:
+				testTree(t, tb.Tree(), tt.ast)
+			case tt.cst != nil:
+				testTree(t, tb.Tree(), tt.cst)
+			}
+		})
 	}
 }
 
diff --git a/driver/semantic_action_test.go b/driver/semantic_action_test.go
index ad58780..d0e769e 100644
--- a/driver/semantic_action_test.go
+++ b/driver/semantic_action_test.go
@@ -194,7 +194,7 @@ char
 				t.Fatal(err)
 			}
 
-			gram, err := grammar.Compile(g, grammar.SpecifyClass(grammar.ClassLALR))
+			gram, err := grammar.Compile(g)
 			if err != nil {
 				t.Fatal(err)
 			}
diff --git a/driver/spec.go b/driver/spec.go
index 6127e73..195cb8c 100644
--- a/driver/spec.go
+++ b/driver/spec.go
@@ -12,10 +12,6 @@ func NewGrammar(g *spec.CompiledGrammar) *grammarImpl {
 	}
 }
 
-func (g *grammarImpl) Class() string {
-	return g.g.ParsingTable.Class
-}
-
 func (g *grammarImpl) InitialState() int {
 	return g.g.ParsingTable.InitialState
 }
diff --git a/driver/syntax_error_test.go b/driver/syntax_error_test.go
index 93cf637..c49d804 100644
--- a/driver/syntax_error_test.go
+++ b/driver/syntax_error_test.go
@@ -126,7 +126,7 @@ c
 				t.Fatal(err)
 			}
 
-			gram, err := grammar.Compile(g, grammar.SpecifyClass(grammar.ClassLALR))
+			gram, err := grammar.Compile(g)
 			if err != nil {
 				t.Fatal(err)
 			}
diff --git a/driver/template.go b/driver/template.go
index aa1fbd3..459b6e0 100644
--- a/driver/template.go
+++ b/driver/template.go
@@ -49,7 +49,6 @@ func GenParser(cgram *spec.CompiledGrammar, pkgName string) ([]byte, error) {
 
 		var b strings.Builder
 		err = t.Execute(&b, map[string]interface{}{
-			"class":            cgram.ParsingTable.Class,
 			"initialState":     cgram.ParsingTable.InitialState,
 			"startProduction":  cgram.ParsingTable.StartProduction,
 			"terminalCount":    cgram.ParsingTable.TerminalCount,
@@ -167,10 +166,6 @@ func NewGrammar() *grammarImpl {
 	}
 }
 
-func (g *grammarImpl) Class() string {
-	return "{{ .class }}"
-}
-
 func (g *grammarImpl) InitialState() int {
 	return {{ .initialState }}
 }