feat: add option for reporting internal errors

Author: frozenbonito

README.md

@@ -68,6 +68,10 @@ ignorePackageGlobs:
 # function whose call is defined on the given interface.
 ignoreInterfaceRegexps:
 - ^(?i)c(?-i)ach(ing|e)
+
+# ReportInternalErrors determines whether wrapcheck should report errors returned
+# from inside the package.
+reportInternalErrors: true
 ```
 
 ## Usage

wrapcheck/testdata/config_reportInternalErrors/.wrapcheck.yaml

@@ -0,0 +1,5 @@
+reportInternalErrors: true
+
+ignoreSigs:
+- .Errorf(
+- errors.New(

wrapcheck/testdata/config_reportInternalErrors/main.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+)
+
+func main() {
+	do()
+}
+
+func do() error {
+	// Internal function
+	if err := fn(); err != nil {
+		return err // want `error should be unwrapped`
+	}
+	if err := fn(); err != nil {
+		return fmt.Errorf("wrap: %w", err)
+	}
+
+	// Internal struct method
+	ss := someStruct{}
+	if err := ss.someMethod(); err != nil {
+		return err // want `error should be unwrapped`
+	}
+	if err := ss.someMethod(); err != nil {
+		return fmt.Errorf("wrap: %w", err)
+	}
+
+	// External function
+	if _, err := json.Marshal(struct{}{}); err != nil {
+		return err // want `error should be unwrapped`
+	}
+	if _, err := json.Marshal(struct{}{}); err != nil {
+		return fmt.Errorf("wrap: %w", err)
+	}
+
+	var si someInterface = &someInterfaceImpl{}
+	if err := si.SomeMethod(); err != nil {
+		return err // want `error should be unwrapped`
+	}
+	if err := si.SomeMethod(); err != nil {
+		return fmt.Errorf("wrap: %w", err)
+	}
+
+	return nil
+}
+
+func fn() error {
+	return errors.New("error")
+}
+
+type someStruct struct{}
+
+func (s *someStruct) someMethod() error {
+	return errors.New("error")
+}
+
+type someInterface interface {
+	SomeMethod() error
+}
+
+type someInterfaceImpl struct {
+	someInterface
+}

wrapcheck/wrapcheck.go

@@ -83,6 +83,10 @@ type WrapcheckConfig struct {
 	// returned from any function whose call is defined on a interface named 'Transactor'
 	// or 'Transaction' due to the name matching the regular expression `Transac(tor|tion)`.
 	IgnoreInterfaceRegexps []string `mapstructure:"ignoreInterfaceRegexps" yaml:"ignoreInterfaceRegexps"`
+
+	// ReportInternalErrors determines whether wrapcheck should report errors returned
+	// from inside the package.
+	ReportInternalErrors bool `mapstructure:"reportInternalErrors" yaml:"reportInternalErrors"`
 }
 
 func NewDefaultConfig() WrapcheckConfig {
@@ -273,6 +277,16 @@ func reportUnwrapped(
 	pkgGlobs []glob.Glob,
 ) {
 
+	if cfg.ReportInternalErrors {
+		// Check if the call is package-internal function
+		fnIdent, ok := call.Fun.(*ast.Ident)
+		if ok {
+			fnSig := pass.TypesInfo.ObjectOf(fnIdent).String()
+			pass.Reportf(tokenPos, "error should be unwrapped: sig: %s", fnSig)
+			return
+		}
+	}
+
 	sel, ok := call.Fun.(*ast.SelectorExpr)
 	if !ok {
 		return
@@ -286,6 +300,13 @@ func reportUnwrapped(
 		return
 	}
 
+	// If `ReportInternalErrors` is true, report immediately.
+	// There is no need to check the details of the selector.
+	if cfg.ReportInternalErrors {
+		pass.Reportf(tokenPos, "error should be unwrapped: sig: %s", fnSig)
+		return
+	}
+
 	// Check if the underlying type of the "x" in x.y.z is an interface, as
 	// errors returned from exported interface types should be wrapped, unless
 	// ignored as per `ignoreInterfaceRegexps`