feat: extends Analyzer with custom allowed errors via functional options

Author: psydvl

errorlint/allowed.go

@@ -7,10 +7,12 @@ import (
 	"strings"
 )
 
-var allowedErrors = []struct {
+type AllowPair struct {
 	err string
 	fun string
-}{
+}
+
+var allowedErrors = []AllowPair{
 	// pkg/archive/tar
 	{err: "io.EOF", fun: "(*archive/tar.Reader).Next"},
 	{err: "io.EOF", fun: "(*archive/tar.Reader).Read"},
@@ -87,25 +89,30 @@ var allowedErrors = []struct {
 
 var allowedErrorsMap = make(map[string]map[string]struct{})
 
-func init() {
-	for _, pair := range allowedErrors {
+func allowedMapAppend(ap []AllowPair) {
+	for _, pair := range ap {
 		if _, ok := allowedErrorsMap[pair.err]; !ok {
 			allowedErrorsMap[pair.err] = make(map[string]struct{})
 		}
 		allowedErrorsMap[pair.err][pair.fun] = struct{}{}
 	}
 }
 
-var allowedErrorWildcards = []struct {
-	err string
-	fun string
-}{
+func init() {
+	allowedMapAppend(allowedErrors)
+}
+
+var allowedErrorWildcards = []AllowPair{
 	// pkg/syscall
 	{err: "syscall.E", fun: "syscall."},
 	// golang.org/x/sys/unix
 	{err: "golang.org/x/sys/unix.E", fun: "golang.org/x/sys/unix."},
 }
 
+func allowedWildcardAppend(ap []AllowPair) {
+	allowedErrorWildcards = append(allowedErrorWildcards, ap...)
+}
+
 func isAllowedErrAndFunc(err, fun string) bool {
 	if allowedFuncs, allowErr := allowedErrorsMap[err]; allowErr {
 		if _, allow := allowedFuncs[fun]; allow {

errorlint/analysis.go

@@ -9,7 +9,10 @@ import (
 	"golang.org/x/tools/go/analysis"
 )
 
-func NewAnalyzer() *analysis.Analyzer {
+func NewAnalyzer(opts ...Option) *analysis.Analyzer {
+	for _, o := range opts {
+		o()
+	}
 	return &analysis.Analyzer{
 		Name:  "errorlint",
 		Doc:   "Source code linter for Go software that can be used to find code that will cause problems with the error wrapping scheme introduced in Go 1.13.",

errorlint/analysis_test.go

@@ -39,6 +39,35 @@ func TestAllowedComparisons(t *testing.T) {
 	analysistest.Run(t, analysistest.TestData(), analyzer, "allowed")
 }
 
+func TestOptions(t *testing.T) {
+	testCases := []struct {
+		desc    string
+		opt     Option
+		pattern string
+	}{
+		{
+			desc: "WithAllowedErrors",
+			opt: WithAllowedErrors([]AllowPair{
+				{err: "io.EOF", fun: "example.com/pkg.Read"},
+			}),
+			pattern: "options/withAllowedErrors",
+		},
+		{
+			desc: "WithAllowedWildcard",
+			opt: WithAllowedWildcard([]AllowPair{
+				{err: "example.com/pkg.ErrMagic", fun: "example.com/pkg.Magic"},
+			}),
+			pattern: "options/withAllowedWildcard",
+		},
+	}
+	for _, tt := range testCases {
+		t.Run(tt.desc, func(t *testing.T) {
+			analyzer := NewAnalyzer(tt.opt)
+			analysistest.Run(t, analysistest.TestData(), analyzer, tt.pattern)
+		})
+	}
+}
+
 func TestIssueRegressions(t *testing.T) {
 	analyzer := NewAnalyzer()
 	analysistest.Run(t, analysistest.TestData(), analyzer, "issues")

errorlint/options.go

@@ -0,0 +1,15 @@
+package errorlint
+
+type Option func()
+
+func WithAllowedErrors(ap []AllowPair) Option {
+	return func() {
+		allowedMapAppend(ap)
+	}
+}
+
+func WithAllowedWildcard(ap []AllowPair) Option {
+	return func() {
+		allowedWildcardAppend(ap)
+	}
+}

errorlint/testdata/src/example.com/pkg/stubs.go

@@ -0,0 +1,18 @@
+package pkg
+
+import (
+	"errors"
+	"io"
+)
+
+func Read(io.Reader) error {
+	return io.EOF
+}
+
+var (
+	ErrMagicOne = errors.New("magic")
+)
+
+func MagicOne() error {
+	return ErrMagicOne
+}

errorlint/testdata/src/options/withAllowedErrors/withAllowedErrors.go

@@ -0,0 +1,15 @@
+package testdata
+
+import (
+	"fmt"
+	"io"
+
+	"example.com/pkg"
+)
+
+func CustomPackageCompare(r io.Reader) {
+	err := pkg.Read(r)
+	if err == io.EOF {
+		fmt.Println(err)
+	}
+}

errorlint/testdata/src/options/withAllowedWildcard/withAllowedWildcard.go

@@ -0,0 +1,14 @@
+package testdata
+
+import (
+	"fmt"
+
+	"example.com/pkg"
+)
+
+func Magic() {
+	err := pkg.MagicOne()
+	if err != pkg.ErrMagicOne {
+		fmt.Println(err)
+	}
+}