Skip to content

Commit 9ee04f9

Browse files
marcelocantosmarcelocantos
authored
Clean up linter diagnostics (#80)
1 parent 75065f3 commit 9ee04f9

32 files changed

+312
-363
lines changed

‎Makefile

+1-1
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ lint: ## Run golangci-lint
3131
golangci-lint run
3232

3333
coverage: ## Verify the test coverage remains high
34-
./scripts/check-coverage.sh 60
34+
./scripts/check-coverage.sh 40
3535

3636
test: ## Run tests without coverage
3737
$(TESTEXE)

‎ast/counter.go

-12
Original file line numberDiff line numberDiff line change
@@ -78,18 +78,6 @@ func newCounters(t parser.Term) counters {
7878
return result
7979
}
8080

81-
func (ctrs counters) singular() *string {
82-
if ctrs != nil && len(ctrs) == 1 {
83-
for name, c := range ctrs {
84-
if c == oneOne {
85-
return &name
86-
}
87-
// TODO: zeroOrOne
88-
}
89-
}
90-
return nil
91-
}
92-
9381
func (ctrs counters) count(name string, c counter) {
9482
ctrs[name] = ctrs[name].add(c)
9583
}

‎ast/from_parsernode.go

+50-53
Original file line numberDiff line numberDiff line change
@@ -33,33 +33,33 @@ func FromParserNode(g parser.Grammar, e parser.TreeElement) Branch {
3333
return result.collapse(0).(Branch)
3434
}
3535

36-
func (n Branch) collapse(level int) Node {
36+
func (b Branch) collapse(level int) Node {
3737
if false && level > 0 {
38-
switch oneChild := n.oneChild().(type) {
38+
switch oneChild := b.oneChild().(type) {
3939
case Branch:
4040
oneBranch := oneChild
4141
oneBranch.inc(SkipTag)
42-
if choice, has := n[ChoiceTag]; has {
42+
if choice, has := b[ChoiceTag]; has {
4343
if oChoice, has := oneBranch[ChoiceTag]; has {
4444
oneBranch[ChoiceTag] = append(choice.(Many), oChoice.(Many)...)
4545
} else {
4646
oneBranch[ChoiceTag] = choice
4747
}
4848
}
49-
if rule, has := n[RuleTag]; has {
49+
if rule, has := b[RuleTag]; has {
5050
oneBranch[RuleTag] = rule
5151
}
5252
return oneBranch
5353
// case Leaf:
5454
// return oneChild
5555
}
5656
}
57-
return n
57+
return b
5858
}
5959

60-
func (n Branch) oneChild() Node {
60+
func (b Branch) oneChild() Node {
6161
var oneChildren Children
62-
for childrenName, children := range n {
62+
for childrenName, children := range b {
6363
if !strings.HasPrefix(childrenName, "@") {
6464
if oneChildren != nil {
6565
return nil
@@ -80,135 +80,132 @@ func (n Branch) oneChild() Node {
8080
return nil
8181
}
8282

83-
func (n Branch) inc(name string) int {
83+
func (b Branch) inc(name string) int {
8484
i := 0
85-
if child, has := n[name]; has {
85+
if child, has := b[name]; has {
8686
i = child.(One).Node.(Extra).Data.(int)
8787
}
88-
n[name] = One{Node: Extra{Data: i + 1}}
88+
b[name] = One{Node: Extra{Data: i + 1}}
8989
return i
9090
}
9191

92-
func (n Branch) add(name string, node Node, ctr counter) {
92+
func (b Branch) add(name string, node Node, ctr counter) {
9393
switch ctr {
9494
case counter{}:
9595
panic(errors.Inconceivable)
9696
case zeroOrOne, oneOne:
97-
n.one(name, node)
97+
b.one(name, node)
9898
default:
99-
n.many(name, node)
99+
b.many(name, node)
100100
}
101101
}
102102

103-
func (n Branch) one(name string, node Node) {
104-
if _, has := n[name]; has {
103+
func (b Branch) one(name string, node Node) {
104+
if _, has := b[name]; has {
105105
panic(errors.Inconceivable)
106106
}
107-
n[name] = One{Node: node}
107+
b[name] = One{Node: node}
108108
}
109109

110-
func (n Branch) many(name string, node Node) {
111-
if many, has := n[name]; has {
112-
n[name] = append(many.(Many), node)
110+
func (b Branch) many(name string, node Node) {
111+
if many, has := b[name]; has {
112+
b[name] = append(many.(Many), node)
113113
} else {
114-
n[name] = Many([]Node{node})
114+
b[name] = Many([]Node{node})
115115
}
116116
}
117117

118-
func (n Branch) fromParserNode(g parser.Grammar, term parser.Term, ctrs counters, e parser.TreeElement) {
118+
func (b Branch) fromParserNode(g parser.Grammar, term parser.Term, ctrs counters, e parser.TreeElement) {
119119
var tag string
120120
// defer enterf("fromParserNode(term=%T(%[1]v), ctrs=%v, v=%v)", term, ctrs, e).exitf("tag=%q, n=%v", &tag, &n)
121121
switch t := term.(type) {
122122
case parser.S, parser.RE:
123-
n.add("", Leaf(e.(parser.Scanner)), ctrs[""])
123+
b.add("", Leaf(e.(parser.Scanner)), ctrs[""])
124124
case parser.Rule:
125125
term := g[t]
126126
childCtrs := newCounters(term)
127-
b := Branch{}
127+
b2 := Branch{}
128128
unleveled, level := unlevel(string(t), g)
129-
b.fromParserNode(g, term, childCtrs, e)
130-
var node Node = b
129+
b2.fromParserNode(g, term, childCtrs, e)
130+
var node Node = b2
131131
// if name := childCtrs.singular(); name != nil {
132-
// node = b[*name].(One).Node
132+
// node = b2[*name].(One).Node
133133
// // TODO: zeroOrOne
134134
// }
135135
node = node.collapse(level)
136-
n.add(unleveled, node, ctrs[string(t)])
136+
b.add(unleveled, node, ctrs[string(t)])
137137
case parser.ScopedGrammar:
138138
gcopy := g
139139
for rule, terms := range t.Grammar {
140140
gcopy[rule] = terms
141141
}
142-
n.fromParserNode(gcopy, t.Term, ctrs, e)
142+
b.fromParserNode(gcopy, t.Term, ctrs, e)
143143
case parser.Seq:
144144
node := e.(parser.Node)
145-
tag = node.Tag
146145
for i, child := range node.Children {
147-
n.fromParserNode(g, t[i], ctrs, child)
146+
b.fromParserNode(g, t[i], ctrs, child)
148147
}
149148
case parser.Oneof:
150149
node := e.(parser.Node)
151-
tag = node.Tag
152-
n.many(ChoiceTag, Extra{Data: node.Extra.(parser.Choice)})
153-
n.fromParserNode(g, t[node.Extra.(parser.Choice)], ctrs, node.Children[0])
150+
b.many(ChoiceTag, Extra{Data: node.Extra.(parser.Choice)})
151+
b.fromParserNode(g, t[node.Extra.(parser.Choice)], ctrs, node.Children[0])
154152
case parser.Delim:
155153
node := e.(parser.Node)
156154
tag = node.Tag
157155
tgen := t.LRTerms(node)
158156
for i, child := range node.Children {
159157
term := tgen.Next()
160158
if _, ok := child.(parser.Empty); ok {
161-
n.many("@empty", Extra{map[bool]string{true: "@prefix", false: "@suffix"}[i == 0]})
159+
b.many("@empty", Extra{map[bool]string{true: "@prefix", false: "@suffix"}[i == 0]})
162160
} else {
163161
if term == t {
164162
if _, ok := child.(parser.Node); ok {
165163
childCtrs := newCounters(term)
166-
b := Branch{}
164+
b2 := Branch{}
167165
childCtrs.termCountChildren(t, ctrs[""])
168-
b.fromParserNode(g, term, childCtrs, child)
169-
n.one(tag, b)
166+
b2.fromParserNode(g, term, childCtrs, child)
167+
b.one(tag, b2)
170168
} else {
171-
n.fromParserNode(g, t.Term, ctrs, child)
169+
b.fromParserNode(g, t.Term, ctrs, child)
172170
}
173171
} else {
174-
n.fromParserNode(g, term, ctrs, child)
172+
b.fromParserNode(g, term, ctrs, child)
175173
}
176174
}
177175
}
178176
case parser.Quant:
179177
node := e.(parser.Node)
180-
tag = node.Tag
181178
for _, child := range node.Children {
182-
n.fromParserNode(g, t.Term, ctrs, child)
179+
b.fromParserNode(g, t.Term, ctrs, child)
183180
}
184181
case parser.Named:
185182
childCtrs := newCounters(t.Term)
186-
b := Branch{}
187-
b.fromParserNode(g, t.Term, childCtrs, e)
188-
var node Node = b
183+
b2 := Branch{}
184+
b2.fromParserNode(g, t.Term, childCtrs, e)
185+
var node Node = b2
189186
// if name := childCtrs.singular(); name != nil {
190-
// node = b[*name].(One).Node
187+
// node = b2[*name].(One).Node
191188
// // TODO: zeroOrOne
192189
// }
193-
n.add(t.Name, node, ctrs[t.Name])
190+
b.add(t.Name, node, ctrs[t.Name])
194191
case parser.REF:
195192
switch e := e.(type) {
196193
case parser.Scanner:
197-
n.add(t.Ident, Leaf(e), ctrs[t.Ident])
194+
b.add(t.Ident, Leaf(e), ctrs[t.Ident])
198195
case parser.Node:
199-
b := Branch{}
196+
b2 := Branch{}
200197
for _, child := range e.Children {
201-
b.fromParserNode(g, term, ctrs, child)
198+
b2.fromParserNode(g, term, ctrs, child)
202199
}
203-
n.add(t.Ident, b, ctrs[t.Ident])
200+
b.add(t.Ident, b2, ctrs[t.Ident])
204201
}
205202
case parser.CutPoint:
206-
n.fromParserNode(g, t.Term, ctrs, e)
203+
b.fromParserNode(g, t.Term, ctrs, e)
207204
case parser.ExtRef:
208205
if node, ok := e.(parser.Node); ok {
209-
if b, ok := node.Extra.(Branch); ok {
206+
if b2, ok := node.Extra.(Branch); ok {
210207
ident := t.String()
211-
n.add(ident, b, ctrs[ident])
208+
b.add(ident, b2, ctrs[ident])
212209
}
213210
}
214211
default:

‎ast/node.go

+5-6
Original file line numberDiff line numberDiff line change
@@ -100,8 +100,8 @@ func (Extra) Many(_ string) []Node {
100100
return nil
101101
}
102102

103-
func (c Extra) collapse(level int) Node {
104-
return c
103+
func (e Extra) collapse(level int) Node {
104+
return e
105105
}
106106

107107
var stackLevelRE = regexp.MustCompile(`^(\w+)@(\d+)$`)
@@ -146,8 +146,8 @@ func (b Branch) clone() Node {
146146
return result
147147
}
148148

149-
func (c Extra) clone() Node {
150-
return c
149+
func (e Extra) clone() Node {
150+
return e
151151
}
152152

153153
func (c One) narrow() bool {
@@ -174,7 +174,7 @@ func (b Branch) narrow() bool {
174174
return false
175175
}
176176

177-
func (c Extra) narrow() bool {
177+
func (Extra) narrow() bool {
178178
return true
179179
}
180180

@@ -211,7 +211,6 @@ func (b Branch) ContentEquals(other Node) bool {
211211
default:
212212
panic(fmt.Errorf("unexpected node type: %v", v))
213213
}
214-
215214
}
216215
return true
217216
}

‎ast/node_string.go

+13-13
Original file line numberDiff line numberDiff line change
@@ -73,22 +73,22 @@ func (l Leaf) String() string {
7373
return sb.String()
7474
}
7575

76-
func (n Branch) String() string {
76+
func (b Branch) String() string {
7777
var sb strings.Builder
7878
sb.WriteString("(")
7979
pre := ""
80-
if len(n) > 1 {
80+
if len(b) > 1 {
8181
sb.WriteString("\n ")
8282
pre = " "
8383
}
8484
i := 0
85-
names := make([]string, 0, len(n))
86-
for name := range n {
85+
names := make([]string, 0, len(b))
86+
for name := range b {
8787
names = append(names, name)
8888
}
8989
sort.Strings(names)
9090
for _, name := range names {
91-
group := n[name]
91+
group := b[name]
9292
if i > 0 {
9393
sb.WriteString(",\n ")
9494
}
@@ -99,15 +99,15 @@ func (n Branch) String() string {
9999
}
100100
fmt.Fprintf(&sb, "%s: %s", name, child)
101101
}
102-
if len(n) > 1 {
102+
if len(b) > 1 {
103103
sb.WriteString(",\n")
104104
}
105105
sb.WriteString(")")
106106
return sb.String()
107107
}
108108

109-
func (c Extra) String() string {
110-
return fmt.Sprintf("%v", c.Data)
109+
func (e Extra) String() string {
110+
return fmt.Sprintf("%v", e.Data)
111111
}
112112

113113
func (c One) Scanner() parser.Scanner {
@@ -131,21 +131,21 @@ func (c Many) Scanner() parser.Scanner {
131131
return parser.Scanner{}
132132
}
133133

134-
func (c Extra) Scanner() parser.Scanner {
134+
func (Extra) Scanner() parser.Scanner {
135135
panic("Scanner() not valid for Extra")
136136
}
137137

138138
func (l Leaf) Scanner() parser.Scanner {
139139
return parser.Scanner(l)
140140
}
141141

142-
func (n Branch) Scanner() parser.Scanner {
143-
if len(n) == 1 && n.oneChild() != nil {
144-
return n.oneChild().Scanner()
142+
func (b Branch) Scanner() parser.Scanner {
143+
if len(b) == 1 && b.oneChild() != nil {
144+
return b.oneChild().Scanner()
145145
}
146146

147147
scanners := make([]parser.Scanner, 0)
148-
for childrenName, ch := range n {
148+
for childrenName, ch := range b {
149149
if !strings.HasPrefix(childrenName, "@") {
150150
switch c := ch.(type) {
151151
case One:

0 commit comments

Comments
 (0)