18691869999

Committed 21 Oct 2025 05:08PM UTC coverage: 70.749% (+1.2%) from 69.501%

Build # 18691869999

Build Type

Pull #52

github

Committed by

ghettovoice

Commit Message

Optimize node cache key building, re-use hasher from pool

Pull Request Pull Request #52: Optimize

Run Details

375 of 439 new or added lines in 8 files covered. (85.42%)

27 existing lines in 4 files now uncovered.

1531 of 2164 relevant lines covered (70.75%)

54.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

5.13

/errors.go

package abnf

import (
        "errors"
        "fmt"
        "strings"
)

const (
        // ErrNotMatched returned by operators if input doesn't match
        ErrNotMatched sentinelError = "not matched"
)

type sentinelError string

func (e sentinelError) Error() string { return string(e) }

type operError struct {
        op  string
        pos uint
        err error
}

func (e operError) Unwrap() error { return e.err }

func (e operError) Error() string {
        var sb strings.Builder
        e.writeError(&sb, 0)
        return sb.String()
}

func (e *operError) writeError(sb *strings.Builder, depth int) {
        fmt.Fprintf(sb, "operator %q failed at position %d: ", e.op, e.pos)

        var merr multiError
        if errors.As(e.err, &merr) {
                merr.writeError(sb, depth)
        } else {
                sb.WriteString(e.err.Error())
        }
}

type multiError []error

func (e multiError) Unwrap() []error { return e }

func (e multiError) Error() string {
        var sb strings.Builder
        e.writeError(&sb, 0)
        return sb.String()
}

func (e multiError) writeError(sb *strings.Builder, depth int) {
        sb.WriteString("following errors are occurred:\n")

        for _, err := range e {
                var (
                        merr multiError
                        oerr *operError
                )
                if errors.As(err, &oerr) {
                        sb.WriteString(strings.Repeat("  ", depth+1) + "- ")
                        oerr.writeError(sb, depth+1)
                        sb.WriteString("\n")
                } else if errors.As(err, &merr) {
                        merr.writeError(sb, depth+1)
                } else {
                        sb.WriteString(strings.Repeat("  ", depth+1) + "- " + err.Error() + "\n")
                }
        }
}

// const multiErrCap = 10

// var multiErrPool = &sync.Pool{
//         New: func() any {
//                 errs := multiError(make([]error, 0, multiErrCap))
//                 return &errs
//         },
// }

// func newMultiErr(c int) multiError {
//         var err multiError
//         if c <= multiErrCap {
//                 err = *(multiErrPool.Get().(*multiError))
//         } else {
//                 err = make(multiError, 0, c)
//         }
//         return err
// }

// func freeMultiErr(err multiError) {
//         if err == nil || cap(err) > 10*multiErrCap {
//                 return
//         }

//         clear(err)
//         multiErrPool.Put(&err)
// }

1	package abnf
2
3	import (
4	"errors"
5	"fmt"
6	"strings"
7	)
8
9	const (
10	// ErrNotMatched returned by operators if input doesn't match
11	ErrNotMatched sentinelError = "not matched"
12	)
13
14	type sentinelError string
15
16	func (e sentinelError) Error() string { return string(e) }	×
17
18	type operError struct {
19	op string
20	pos uint
21	err error
22	}
23
24	func (e operError) Unwrap() error { return e.err }	36✔
25
NEW 26	func (e operError) Error() string {	×
27	var sb strings.Builder	×
28	e.writeError(&sb, 0)	×
29	return sb.String()	×
30	}	×
31
32	func (e operError) writeError(sb strings.Builder, depth int) {	×
33	fmt.Fprintf(sb, "operator %q failed at position %d: ", e.op, e.pos)	×
34		×
35	var merr multiError	×
36	if errors.As(e.err, &merr) {	×
37	merr.writeError(sb, depth)	×
38	} else {	×
39	sb.WriteString(e.err.Error())	×
40	}	×
41	}
42
43	type multiError []error
44
45	func (e multiError) Unwrap() []error { return e }	10✔
46
47	func (e multiError) Error() string {	×
48	var sb strings.Builder	×
49	e.writeError(&sb, 0)	×
50	return sb.String()	×
51	}	×
52
53	func (e multiError) writeError(sb *strings.Builder, depth int) {	×
54	sb.WriteString("following errors are occurred:\n")	×
55		×
56	for _, err := range e {	×
57	var (	×
58	merr multiError	×
59	oerr *operError	×
60	)	×
61	if errors.As(err, &oerr) {	×
62	sb.WriteString(strings.Repeat(" ", depth+1) + "- ")	×
63	oerr.writeError(sb, depth+1)	×
64	sb.WriteString("\n")	×
65	} else if errors.As(err, &merr) {	×
66	merr.writeError(sb, depth+1)	×
67	} else {	×
68	sb.WriteString(strings.Repeat(" ", depth+1) + "- " + err.Error() + "\n")	×
69	}	×
70	}
71	}
72
73	// const multiErrCap = 10
74
75	// var multiErrPool = &sync.Pool{
76	// New: func() any {
77	// errs := multiError(make([]error, 0, multiErrCap))
78	// return &errs
79	// },
80	// }
81
82	// func newMultiErr(c int) multiError {
83	// var err multiError
84	// if c <= multiErrCap {
85	// err = (multiErrPool.Get().(multiError))
86	// } else {
87	// err = make(multiError, 0, c)
88	// }
89	// return err
90	// }
91
92	// func freeMultiErr(err multiError) {
93	// if err == nil \|\| cap(err) > 10*multiErrCap {
94	// return
95	// }
96
97	// clear(err)
98	// multiErrPool.Put(&err)
99	// }

ghettovoice / abnf / 18691869999

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous