d1365c4 refactor(vimkeys): enforce parser invariants · dumber

M internal/domain/vimkeys/parse.go +127 -85


@@ -6,27 +6,13 @@ import (
6	6		"unicode/utf8"
7	7		)
8	8
9		-	var specialAliases = map[string]string{
10		-	"cr": "CR",
11		-	"return": "CR",
12		-	"esc": "Esc",
13		-	"escape": "Esc",
14		-	"space": "Space",
15		-	"lt": "<",
16		-	"plus": "+",
17		-	}
18		-
19	9		func ParseBinding(s string) (Sequence, error) {
20	10		s = strings.TrimSpace(s)
21	11		if s == "" {
22	12		return nil, ErrEmptyBinding
23	13		}
24	14
25		-	if looksLikeChordAttempt(s) {
26		-	if !isLegacyChord(s) {
27		-	return nil, ErrBadBinding
28		-	}
29		-	key, err := parseLegacyChord(s)
	15	+	if key, ok, err := tryParseAsLegacyChord(s); ok {
30	16		if err != nil {
31	17		return nil, err
32	18		}

@@ -35,14 +21,45 @@ func ParseBinding(s string) (Sequence, error) {
35	21		return parseRawSequence(s)
36	22		}
37	23
38		-	func looksLikeChordAttempt(s string) bool {
39		-	if s == "+" {
	24	+	func legacyChordParts(s string) []string {
	25	+	parts := strings.Split(s, "+")
	26	+	tokens := make([]string, 0, len(parts))
	27	+	for _, part := range parts {
	28	+	if part = strings.TrimSpace(part); part != "" {
	29	+	tokens = append(tokens, part)
	30	+	}
	31	+	}
	32	+	return tokens
	33	+	}
	34	+
	35	+	func isModifierName(part string) bool {
	36	+	switch strings.ToLower(part) {
	37	+	case "ctrl", "control", "shift", "alt":
40	38		return true
	39	+	default:
	40	+	return false
	41	+	}
	42	+	}
	43	+
	44	+	func tryParseAsLegacyChord(s string) (Key, bool, error) {
	45	+	if s == "+" {
	46	+	return Key{Sym: "+"}, true, nil
	47	+	}
	48	+
	49	+	parts := legacyChordParts(s)
	50	+	if !legacyChordLooksLikeAttempt(s, parts) {
	51	+	return Key{}, false, nil
41	52		}
	53	+
	54	+	key, err := buildLegacyChordKey(s, parts)
	55	+	return key, true, err
	56	+	}
	57	+
	58	+	func legacyChordLooksLikeAttempt(s string, parts []string) bool {
42	59		if strings.HasSuffix(s, "++") {
43	60		return true
44	61		}
45		-	for _, part := range strings.Split(s, "+") {
	62	+	for _, part := range parts {
46	63		if isModifierName(part) {
47	64		return true
48	65		}

@@ -50,84 +67,77 @@ func looksLikeChordAttempt(s string) bool {
50	67		return false
51	68		}
52	69
53		-	func isLegacyChord(s string) bool {
54		-	if s == "+" {
55		-	return true
56		-	}
	70	+	func validateLegacyChordLayout(s string, parts []string) error {
57	71		if !strings.Contains(s, "+") {
58		-	return false
	72	+	return ErrBadBinding
59	73		}
60	74		if strings.HasSuffix(s, "++") {
61		-	return true
	75	+	return nil
62	76		}
63		-	parts := strings.Split(s, "+")
64	77		for i, part := range parts {
65		-	part = strings.TrimSpace(part)
66		-	if part == "" {
67		-	continue
68		-	}
69	78		if isModifierName(part) {
70	79		continue
71	80		}
72		-	if i == len(parts)-1 {
73		-	return true
	81	+	if i != len(parts)-1 {
	82	+	return ErrBadBinding
74	83		}
75		-	return false
76	84		}
77		-	return false
	85	+	return nil
78	86		}
79	87
80		-	func isModifierName(part string) bool {
	88	+	func modsFromLegacyPart(part string) (Mods, bool) {
81	89		switch strings.ToLower(part) {
82		-	case "ctrl", "control", "shift", "alt":
83		-	return true
	90	+	case "ctrl", "control":
	91	+	return ModCtrl, true
	92	+	case "shift":
	93	+	return ModShift, true
	94	+	case "alt":
	95	+	return ModAlt, true
84	96		default:
85		-	return false
	97	+	return 0, false
86	98		}
87	99		}
88	100
89		-	func parseLegacyChord(s string) (Key, error) {
90		-	if s == "+" {
91		-	return Key{Sym: "+"}, nil
	101	+	func collectLegacyChordModsAndKey(s string, parts []string) (Mods, string, error) {
	102	+	if err := validateLegacyChordLayout(s, parts); err != nil {
	103	+	return 0, "", err
92	104		}
93	105
94		-	parts := strings.Split(s, "+")
95	106		var mods Mods
96		-	var keyPart string
97		-
	107	+	keyPart := ""
98	108		for _, part := range parts {
99		-	part = strings.TrimSpace(part)
100		-	if part == "" {
	109	+	if mod, ok := modsFromLegacyPart(part); ok {
	110	+	mods \|= mod
101	111		continue
102	112		}
103		-	lower := strings.ToLower(part)
104		-	switch lower {
105		-	case "ctrl", "control":
106		-	mods \|= ModCtrl
107		-	case "shift":
108		-	mods \|= ModShift
109		-	case "alt":
110		-	mods \|= ModAlt
111		-	default:
112		-	if keyPart != "" {
113		-	return Key{}, ErrBadBinding
114		-	}
115		-	keyPart = part
	113	+	if keyPart != "" {
	114	+	return 0, "", ErrBadBinding
116	115		}
	116	+	keyPart = part
117	117		}
118	118
119	119		if keyPart == "" && strings.HasSuffix(s, "++") {
120	120		keyPart = "+"
121	121		}
122	122		if keyPart == "" {
123		-	return Key{}, ErrBadBinding
	123	+	return 0, "", ErrBadBinding
124	124		}
	125	+	return mods, keyPart, nil
	126	+	}
125	127
	128	+	func legacyKeyPartWithShift(keyPart string, mods Mods) (string, Mods) {
126	129		if len(keyPart) == 1 && keyPart[0] >= 'A' && keyPart[0] <= 'Z' {
127		-	mods \|= ModShift
128		-	keyPart = strings.ToLower(keyPart)
	130	+	return strings.ToLower(keyPart), mods \| ModShift
129	131		}
	132	+	return keyPart, mods
	133	+	}
130	134
	135	+	func buildLegacyChordKey(s string, parts []string) (Key, error) {
	136	+	mods, keyPart, err := collectLegacyChordModsAndKey(s, parts)
	137	+	if err != nil {
	138	+	return Key{}, err
	139	+	}
	140	+	keyPart, mods = legacyKeyPartWithShift(keyPart, mods)
131	141		sym, err := symFromToken(keyPart, false)
132	142		if err != nil {
133	143		return Key{}, err

@@ -152,18 +162,11 @@ func parseAngleToken(inner string) (Key, error) {
152	162		if modPart == "" {
153	163		return Key{}, ErrBadBinding
154	164		}
155		-	for _, ch := range modPart {
156		-	switch ch {
157		-	case 'C', 'c':
158		-	mods \|= ModCtrl
159		-	case 'S', 's':
160		-	mods \|= ModShift
161		-	case 'A', 'a':
162		-	mods \|= ModAlt
163		-	default:
164		-	return Key{}, ErrBadBinding
165		-	}
	165	+	partMods, err := modsFromCompactModString(modPart)
	166	+	if err != nil {
	167	+	return Key{}, err
166	168		}
	169	+	mods \|= partMods
167	170		}
168	171
169	172		sym, err := symFromToken(symPart, true)

@@ -180,7 +183,22 @@ func parseAngleToken(inner string) (Key, error) {
180	183		return Key{Sym: sym}, nil
181	184		}
182	185
183		-	var sequenceSpecialNames = []string{"Space", "Esc", "CR", "lt", "Plus"}
	186	+	func modsFromCompactModString(modPart string) (Mods, error) {
	187	+	var mods Mods
	188	+	for _, ch := range modPart {
	189	+	switch ch {
	190	+	case 'C', 'c':
	191	+	mods \|= ModCtrl
	192	+	case 'S', 's':
	193	+	mods \|= ModShift
	194	+	case 'A', 'a':
	195	+	mods \|= ModAlt
	196	+	default:
	197	+	return 0, ErrBadBinding
	198	+	}
	199	+	}
	200	+	return mods, nil
	201	+	}
184	202
185	203		func parseRawSequence(s string) (Sequence, error) {
186	204		seq := make(Sequence, 0, len(s))

@@ -237,17 +255,24 @@ func parseAngleAt(s string, i int) (Key, int, error) {
237	255		}
238	256
239	257		func tryParseSpecialAt(s string, i int) (Key, int, bool) {
240		-	for _, name := range sequenceSpecialNames {
241		-	if !strings.HasPrefix(s[i:], name) {
242		-	continue
243		-	}
244		-	sym, err := symFromAlias(name)
245		-	if err != nil {
246		-	continue
247		-	}
248		-	return Key{Sym: sym}, len(name), true
	258	+	if i >= len(s) {
	259	+	return Key{}, 0, false
	260	+	}
	261	+	rest := s[i:]
	262	+	switch {
	263	+	case strings.HasPrefix(rest, "Space"):
	264	+	return Key{Sym: "Space"}, len("Space"), true
	265	+	case strings.HasPrefix(rest, "Plus"):
	266	+	return Key{Sym: "+"}, len("Plus"), true
	267	+	case strings.HasPrefix(rest, "Esc"):
	268	+	return Key{Sym: "Esc"}, len("Esc"), true
	269	+	case strings.HasPrefix(rest, "CR"):
	270	+	return Key{Sym: "CR"}, len("CR"), true
	271	+	case strings.HasPrefix(rest, "lt"):
	272	+	return Key{Sym: "<"}, len("lt"), true
	273	+	default:
	274	+	return Key{}, 0, false
249	275		}
250		-	return Key{}, 0, false
251	276		}
252	277
253	278		func tryParseCanonicalAt(s string, i int) (Key, int, bool) {

@@ -336,8 +361,25 @@ func shiftedGlyphForRune(r rune) (string, bool) {
336	361		}
337	362		}
338	363
	364	+	func symFromSpecialAlias(token string) (string, bool) {
	365	+	switch strings.ToLower(token) {
	366	+	case "cr", "return":
	367	+	return "CR", true
	368	+	case "esc", "escape":
	369	+	return "Esc", true
	370	+	case "space":
	371	+	return "Space", true
	372	+	case "lt":
	373	+	return "<", true
	374	+	case "plus":
	375	+	return "+", true
	376	+	default:
	377	+	return "", false
	378	+	}
	379	+	}
	380	+
339	381		func symFromToken(token string, allowSingleLetter bool) (string, error) {
340		-	if sym, ok := specialAliases[strings.ToLower(token)]; ok {
	382	+	if sym, ok := symFromSpecialAlias(token); ok {
341	383		return sym, nil
342	384		}
343	385		if allowSingleLetter && len(token) == 1 {

@@ -356,7 +398,7 @@ func symFromToken(token string, allowSingleLetter bool) (string, error) {
356	398		}
357	399
358	400		func symFromAlias(token string) (string, error) {
359		-	if sym, ok := specialAliases[strings.ToLower(token)]; ok {
	401	+	if sym, ok := symFromSpecialAlias(token); ok {
360	402		return sym, nil
361	403		}
362	404		return "", ErrBadBinding

 	"unicode/utf8"
 )
-var specialAliases = map[string]string{
-	"cr":     "CR",
-	"return": "CR",
-	"esc":    "Esc",
-	"escape": "Esc",
-	"space":  "Space",
-	"lt":     "<",
-	"plus":   "+",
-}
 func ParseBinding(s string) (Sequence, error) {
 	s = strings.TrimSpace(s)
 	if s == "" {
 		return nil, ErrEmptyBinding
 	}
-	if looksLikeChordAttempt(s) {
+	if key, ok, err := tryParseAsLegacyChord(s); ok {
-		if !isLegacyChord(s) {
-			return nil, ErrBadBinding
-		}
-		key, err := parseLegacyChord(s)
 		if err != nil {
 			return nil, err
 		}
 	return parseRawSequence(s)
 }
-func looksLikeChordAttempt(s string) bool {
+func legacyChordParts(s string) []string {
-	if s == "+" {
+	parts := strings.Split(s, "+")
+	tokens := make([]string, 0, len(parts))
+	for _, part := range parts {
+		if part = strings.TrimSpace(part); part != "" {
+			tokens = append(tokens, part)
+		}
+	}
+	return tokens
+}
+func isModifierName(part string) bool {
+	switch strings.ToLower(part) {
+	case "ctrl", "control", "shift", "alt":
 		return true
+	default:
+		return false
+	}
+}
+func tryParseAsLegacyChord(s string) (Key, bool, error) {
+	if s == "+" {
+		return Key{Sym: "+"}, true, nil
+	}
+	parts := legacyChordParts(s)
+	if !legacyChordLooksLikeAttempt(s, parts) {
+		return Key{}, false, nil
 	}
+	key, err := buildLegacyChordKey(s, parts)
+	return key, true, err
+}
+func legacyChordLooksLikeAttempt(s string, parts []string) bool {
 	if strings.HasSuffix(s, "++") {
 		return true
 	}
-	for _, part := range strings.Split(s, "+") {
+	for _, part := range parts {
 		if isModifierName(part) {
 			return true
 		}
 	return false
 }
-func isLegacyChord(s string) bool {
+func validateLegacyChordLayout(s string, parts []string) error {
-	if s == "+" {
-		return true
-	}
 	if !strings.Contains(s, "+") {
-		return false
+		return ErrBadBinding
 	}
 	if strings.HasSuffix(s, "++") {
-		return true
+		return nil
 	}
-	parts := strings.Split(s, "+")
 	for i, part := range parts {
-		part = strings.TrimSpace(part)
-		if part == "" {
-			continue
-		}
 		if isModifierName(part) {
 			continue
 		}
-		if i == len(parts)-1 {
+		if i != len(parts)-1 {
-			return true
+			return ErrBadBinding
 		}
-		return false
 	}
-	return false
+	return nil
 }
-func isModifierName(part string) bool {
+func modsFromLegacyPart(part string) (Mods, bool) {
 	switch strings.ToLower(part) {
-	case "ctrl", "control", "shift", "alt":
+	case "ctrl", "control":
-		return true
+		return ModCtrl, true
+	case "shift":
+		return ModShift, true
+	case "alt":
+		return ModAlt, true
 	default:
-		return false
+		return 0, false
 	}
 }
-func parseLegacyChord(s string) (Key, error) {
+func collectLegacyChordModsAndKey(s string, parts []string) (Mods, string, error) {
-	if s == "+" {
+	if err := validateLegacyChordLayout(s, parts); err != nil {
-		return Key{Sym: "+"}, nil
+		return 0, "", err
 	}
-	parts := strings.Split(s, "+")
 	var mods Mods
-	var keyPart string
+	keyPart := ""
 	for _, part := range parts {
-		part = strings.TrimSpace(part)
+		if mod, ok := modsFromLegacyPart(part); ok {
-		if part == "" {
+			mods |= mod
 			continue
 		}
-		lower := strings.ToLower(part)
+		if keyPart != "" {
-		switch lower {
+			return 0, "", ErrBadBinding
-		case "ctrl", "control":
-			mods |= ModCtrl
-		case "shift":
-			mods |= ModShift
-		case "alt":
-			mods |= ModAlt
-		default:
-			if keyPart != "" {
-				return Key{}, ErrBadBinding
-			}
-			keyPart = part
 		}
+		keyPart = part
 	}
 	if keyPart == "" && strings.HasSuffix(s, "++") {
 		keyPart = "+"
 	}
 	if keyPart == "" {
-		return Key{}, ErrBadBinding
+		return 0, "", ErrBadBinding
 	}
+	return mods, keyPart, nil
+}
+func legacyKeyPartWithShift(keyPart string, mods Mods) (string, Mods) {
 	if len(keyPart) == 1 && keyPart[0] >= 'A' && keyPart[0] <= 'Z' {
-		mods |= ModShift
+		return strings.ToLower(keyPart), mods | ModShift
-		keyPart = strings.ToLower(keyPart)
 	}
+	return keyPart, mods
+}
+func buildLegacyChordKey(s string, parts []string) (Key, error) {
+	mods, keyPart, err := collectLegacyChordModsAndKey(s, parts)
+	if err != nil {
+		return Key{}, err
+	}
+	keyPart, mods = legacyKeyPartWithShift(keyPart, mods)
 	sym, err := symFromToken(keyPart, false)
 	if err != nil {
 		return Key{}, err
 			if modPart == "" {
 				return Key{}, ErrBadBinding
 			}
-			for _, ch := range modPart {
+			partMods, err := modsFromCompactModString(modPart)
-				switch ch {
+			if err != nil {
-				case 'C', 'c':
+				return Key{}, err
-					mods |= ModCtrl
-				case 'S', 's':
-					mods |= ModShift
-				case 'A', 'a':
-					mods |= ModAlt
-				default:
-					return Key{}, ErrBadBinding
-				}
 			}
+			mods |= partMods
 		}
 		sym, err := symFromToken(symPart, true)
 	return Key{Sym: sym}, nil
 }
-var sequenceSpecialNames = []string{"Space", "Esc", "CR", "lt", "Plus"}
+func modsFromCompactModString(modPart string) (Mods, error) {
+	var mods Mods
+	for _, ch := range modPart {
+		switch ch {
+		case 'C', 'c':
+			mods |= ModCtrl
+		case 'S', 's':
+			mods |= ModShift
+		case 'A', 'a':
+			mods |= ModAlt
+		default:
+			return 0, ErrBadBinding
+		}
+	}
+	return mods, nil
+}
 func parseRawSequence(s string) (Sequence, error) {
 	seq := make(Sequence, 0, len(s))
 }
 func tryParseSpecialAt(s string, i int) (Key, int, bool) {
-	for _, name := range sequenceSpecialNames {
+	if i >= len(s) {
-		if !strings.HasPrefix(s[i:], name) {
+		return Key{}, 0, false
-			continue
+	}
-		}
+	rest := s[i:]
-		sym, err := symFromAlias(name)
+	switch {
-		if err != nil {
+	case strings.HasPrefix(rest, "Space"):
-			continue
+		return Key{Sym: "Space"}, len("Space"), true
-		}
+	case strings.HasPrefix(rest, "Plus"):
-		return Key{Sym: sym}, len(name), true
+		return Key{Sym: "+"}, len("Plus"), true
+	case strings.HasPrefix(rest, "Esc"):
+		return Key{Sym: "Esc"}, len("Esc"), true
+	case strings.HasPrefix(rest, "CR"):
+		return Key{Sym: "CR"}, len("CR"), true
+	case strings.HasPrefix(rest, "lt"):
+		return Key{Sym: "<"}, len("lt"), true
+	default:
+		return Key{}, 0, false
 	}
-	return Key{}, 0, false
 }
 func tryParseCanonicalAt(s string, i int) (Key, int, bool) {
 	}
 }
+func symFromSpecialAlias(token string) (string, bool) {
+	switch strings.ToLower(token) {
+	case "cr", "return":
+		return "CR", true
+	case "esc", "escape":
+		return "Esc", true
+	case "space":
+		return "Space", true
+	case "lt":
+		return "<", true
+	case "plus":
+		return "+", true
+	default:
+		return "", false
+	}
+}
 func symFromToken(token string, allowSingleLetter bool) (string, error) {
-	if sym, ok := specialAliases[strings.ToLower(token)]; ok {
+	if sym, ok := symFromSpecialAlias(token); ok {
 		return sym, nil
 	}
 	if allowSingleLetter && len(token) == 1 {
 }
 func symFromAlias(token string) (string, error) {
-	if sym, ok := specialAliases[strings.ToLower(token)]; ok {
+	if sym, ok := symFromSpecialAlias(token); ok {
 		return sym, nil
 	}
 	return "", ErrBadBinding

M internal/domain/vimkeys/trie.go +4 -0


@@ -36,7 +36,11 @@ func newTrieNode() *trieNode {
36	36		}
37	37
38	38		// Insert adds a binding for seq. Duplicate sequences return ErrConflict.
	39	+	// Nil or empty sequences return ErrEmptyBinding.
39	40		func (t *Trie) Insert(seq Sequence, action string) error {
	41	+	if len(seq) == 0 {
	42	+	return ErrEmptyBinding
	43	+	}
40	44		node := t.root
41	45		for _, key := range seq {
42	46		child, ok := node.children[key]


@@ -36,7 +36,11 @@ func newTrieNode() *trieNode {
36	}	36		}
37		37
38	// Insert adds a binding for seq. Duplicate sequences return ErrConflict.	38		// Insert adds a binding for seq. Duplicate sequences return ErrConflict.
		39	+	// Nil or empty sequences return ErrEmptyBinding.
39	func (t *Trie) Insert(seq Sequence, action string) error {	40		func (t *Trie) Insert(seq Sequence, action string) error {
		41	+	if len(seq) == 0 {
		42	+	return ErrEmptyBinding
		43	+	}
40	node := t.root	44		node := t.root
41	for _, key := range seq {	45		for _, key := range seq {
42	child, ok := node.children[key]	46		child, ok := node.children[key]

M internal/domain/vimkeys/trie_test.go +29 -3


@@ -70,13 +70,37 @@ func TestTrie_InsertDuplicateReturnsConflict(t *testing.T) {
70	70		}
71	71		}
72	72
	73	+	func TestTrie_InsertEmptySequenceReturnsErrEmptyBinding(t *testing.T) {
	74	+	trie := NewTrie()
	75	+	for _, seq := range []Sequence{nil, {}} {
	76	+	err := trie.Insert(seq, "root-action")
	77	+	if !errors.Is(err, ErrEmptyBinding) {
	78	+	t.Fatalf("Insert(%v) error = %v, want %v", seq, err, ErrEmptyBinding)
	79	+	}
	80	+	}
	81	+	node, ok := trie.Walk(nil)
	82	+	if !ok {
	83	+	t.Fatal("Walk(nil) ok = false, want true for empty path")
	84	+	}
	85	+	if node.Exact \|\| node.Action != "" {
	86	+	t.Fatalf("Walk(nil) after rejected empty Insert = %+v, want no root action", node)
	87	+	}
	88	+	if trie.MaxDepth() != 0 {
	89	+	t.Fatalf("MaxDepth() = %d after rejected empty Insert, want 0", trie.MaxDepth())
	90	+	}
	91	+	}
	92	+
73	93		func TestTrie_MaxDepth(t *testing.T) {
74	94		trie := NewTrie()
75	95		if got := trie.MaxDepth(); got != 0 {
76	96		t.Fatalf("empty MaxDepth() = %d, want 0", got)
77	97		}
78		-	_ = trie.Insert(Sequence{{Sym: "y"}, {Sym: "a"}, {Sym: "h"}}, "yah")
79		-	_ = trie.Insert(Sequence{{Sym: "]"}, {Sym: "]"}}, "brackets")
	98	+	if err := trie.Insert(Sequence{{Sym: "y"}, {Sym: "a"}, {Sym: "h"}}, "yah"); err != nil {
	99	+	t.Fatalf("Insert(yah) error = %v", err)
	100	+	}
	101	+	if err := trie.Insert(Sequence{{Sym: "]"}, {Sym: "]"}}, "brackets"); err != nil {
	102	+	t.Fatalf("Insert(]]) error = %v", err)
	103	+	}
80	104		if got := trie.MaxDepth(); got != 3 {
81	105		t.Fatalf("MaxDepth() = %d, want 3", got)
82	106		}

@@ -84,7 +108,9 @@ func TestTrie_MaxDepth(t *testing.T) {
84	108
85	109		func TestTrie_WalkMissingPath(t *testing.T) {
86	110		trie := NewTrie()
87		-	_ = trie.Insert(Sequence{{Sym: "j"}}, "down")
	111	+	if err := trie.Insert(Sequence{{Sym: "j"}}, "down"); err != nil {
	112	+	t.Fatalf("Insert(j) error = %v", err)
	113	+	}
88	114		_, ok := trie.Walk(Sequence{{Sym: "k"}})
89	115		if ok {
90	116		t.Fatal("Walk missing path ok = true, want false")


@@ -70,13 +70,37 @@ func TestTrie_InsertDuplicateReturnsConflict(t *testing.T) {
70		}	70		}
71		}	71		}
72			72
			73	+	func TestTrie_InsertEmptySequenceReturnsErrEmptyBinding(t *testing.T) {
			74	+	trie := NewTrie()
			75	+	for _, seq := range []Sequence{nil, {}} {
			76	+	err := trie.Insert(seq, "root-action")
			77	+	if !errors.Is(err, ErrEmptyBinding) {
			78	+	t.Fatalf("Insert(%v) error = %v, want %v", seq, err, ErrEmptyBinding)
			79	+	}
			80	+	}
			81	+	node, ok := trie.Walk(nil)
			82	+	if !ok {
			83	+	t.Fatal("Walk(nil) ok = false, want true for empty path")
			84	+	}
			85	+	if node.Exact \|\| node.Action != "" {
			86	+	t.Fatalf("Walk(nil) after rejected empty Insert = %+v, want no root action", node)
			87	+	}
			88	+	if trie.MaxDepth() != 0 {
			89	+	t.Fatalf("MaxDepth() = %d after rejected empty Insert, want 0", trie.MaxDepth())
			90	+	}
			91	+	}
			92	+
73		func TestTrie_MaxDepth(t *testing.T) {	93		func TestTrie_MaxDepth(t *testing.T) {
74		trie := NewTrie()	94		trie := NewTrie()
75		if got := trie.MaxDepth(); got != 0 {	95		if got := trie.MaxDepth(); got != 0 {
76		t.Fatalf("empty MaxDepth() = %d, want 0", got)	96		t.Fatalf("empty MaxDepth() = %d, want 0", got)
77		}	97		}
78	-	_ = trie.Insert(Sequence{{Sym: "y"}, {Sym: "a"}, {Sym: "h"}}, "yah")	98	+	if err := trie.Insert(Sequence{{Sym: "y"}, {Sym: "a"}, {Sym: "h"}}, "yah"); err != nil {
79	-	_ = trie.Insert(Sequence{{Sym: "]"}, {Sym: "]"}}, "brackets")	99	+	t.Fatalf("Insert(yah) error = %v", err)
			100	+	}
			101	+	if err := trie.Insert(Sequence{{Sym: "]"}, {Sym: "]"}}, "brackets"); err != nil {
			102	+	t.Fatalf("Insert(]]) error = %v", err)
			103	+	}
80		if got := trie.MaxDepth(); got != 3 {	104		if got := trie.MaxDepth(); got != 3 {
81		t.Fatalf("MaxDepth() = %d, want 3", got)	105		t.Fatalf("MaxDepth() = %d, want 3", got)
82		}	106		}

@@ -84,7 +108,9 @@ func TestTrie_MaxDepth(t *testing.T) {
84			108
85		func TestTrie_WalkMissingPath(t *testing.T) {	109		func TestTrie_WalkMissingPath(t *testing.T) {
86		trie := NewTrie()	110		trie := NewTrie()
87	-	_ = trie.Insert(Sequence{{Sym: "j"}}, "down")	111	+	if err := trie.Insert(Sequence{{Sym: "j"}}, "down"); err != nil {
			112	+	t.Fatalf("Insert(j) error = %v", err)
			113	+	}
88		_, ok := trie.Walk(Sequence{{Sym: "k"}})	114		_, ok := trie.Walk(Sequence{{Sym: "k"}})
89		if ok {	115		if ok {
90		t.Fatal("Walk missing path ok = true, want false")	116		t.Fatal("Walk missing path ok = true, want false")