feat: Add the -errorf-multi flag

This makes it possible to enforce multiple wraps only when desired. When
still using Go 1.19, it is recommended to set this flag to false.

Author: polyfloyd

errorlint/analysis.go

@@ -19,16 +19,18 @@ func NewAnalyzer() *analysis.Analyzer {
 }
 
 var (
-	flagSet         flag.FlagSet
-	checkComparison bool
-	checkAsserts    bool
-	checkErrorf     bool
+	flagSet          flag.FlagSet
+	checkComparison  bool
+	checkAsserts     bool
+	checkErrorf      bool
+	checkErrorfMulti bool
 )
 
 func init() {
 	flagSet.BoolVar(&checkComparison, "comparison", true, "Check for plain error comparisons")
 	flagSet.BoolVar(&checkAsserts, "asserts", true, "Check for plain type assertions and type switches")
 	flagSet.BoolVar(&checkErrorf, "errorf", false, "Check whether fmt.Errorf uses the %w verb for formatting errors. See the readme for caveats")
+	flagSet.BoolVar(&checkErrorfMulti, "errorf-multi", true, "Permit more than 1 %w verb, valid per Go 1.20 (Requires -errorf=true)")
 }
 
 func run(pass *analysis.Pass) (interface{}, error) {
@@ -43,7 +45,7 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		lints = append(lints, l...)
 	}
 	if checkErrorf {
-		l := LintFmtErrorfCalls(pass.Fset, *pass.TypesInfo)
+		l := LintFmtErrorfCalls(pass.Fset, *pass.TypesInfo, checkErrorfMulti)
 		lints = append(lints, l...)
 	}
 	sort.Sort(ByPosition(lints))

errorlint/analysis_test.go

@@ -17,13 +17,23 @@ func TestErrorsIs(t *testing.T) {
 
 func TestFmtErrorf(t *testing.T) {
 	analyzer := NewAnalyzer()
-	err := analyzer.Flags.Set("errorf", "true")
-	if err != nil {
+	if err := analyzer.Flags.Set("errorf", "true"); err != nil {
 		log.Fatal(err)
 	}
 	analysistest.Run(t, analysistest.TestData(), analyzer, "fmterrorf")
 }
 
+func TestFmtErrorfMultiple(t *testing.T) {
+	analyzer := NewAnalyzer()
+	if err := analyzer.Flags.Set("errorf", "true"); err != nil {
+		log.Fatal(err)
+	}
+	if err := analyzer.Flags.Set("errorf-multi", "false"); err != nil {
+		log.Fatal(err)
+	}
+	analysistest.Run(t, analysistest.TestData(), analyzer, "fmterrorf-go1.19")
+}
+
 func TestAllowedComparisons(t *testing.T) {
 	analyzer := NewAnalyzer()
 	analysistest.Run(t, analysistest.TestData(), analyzer, "allowed")

errorlint/lint.go

@@ -22,7 +22,7 @@ func (l ByPosition) Less(i, j int) bool {
 	return l[i].Pos < l[j].Pos
 }
 
-func LintFmtErrorfCalls(fset *token.FileSet, info types.Info) []Lint {
+func LintFmtErrorfCalls(fset *token.FileSet, info types.Info, multipleWraps bool) []Lint {
 	lints := []Lint{}
 	for expr, t := range info.Types {
 		// Search for error expressions that are the result of fmt.Errorf
@@ -42,30 +42,38 @@ func LintFmtErrorfCalls(fset *token.FileSet, info types.Info) []Lint {
 		}
 
 		// For any arguments that are errors, check whether the wrapping verb is used. %w may occur
-		// for multiple errors in one Errorf invocation. We raise an issue if at least one error
-		// does not have a corresponding wrapping verb.
-		var lintArg ast.Expr
+		// for multiple errors in one Errorf invocation, unless multipleWraps is true. We raise an
+		// issue if at least one error does not have a corresponding wrapping verb.
 		args := call.Args[1:]
+		wrapCount := 0
 		for i := 0; i < len(args) && i < len(formatVerbs); i++ {
 			if !implementsError(info.Types[args[i]].Type) && !isErrorStringCall(info, args[i]) {
 				continue
 			}
+			verb := formatVerbs[i]
 
-			if formatVerbs[i] == "w" {
-				continue
+			if verb == "w" {
+				wrapCount++
+				if multipleWraps {
+					continue
+				}
+				if wrapCount > 1 {
+					lints = append(lints, Lint{
+						Message: "only one %w verb is permitted per format string",
+						Pos:     args[i].Pos(),
+					})
+					break
+				}
 			}
 
-			if lintArg == nil {
-				lintArg = args[i]
+			if multipleWraps && wrapCount == 0 {
+				lints = append(lints, Lint{
+					Message: "non-wrapping format verb for fmt.Errorf. Use `%w` to format errors",
+					Pos:     args[i].Pos(),
+				})
 				break
 			}
 		}
-		if lintArg != nil {
-			lints = append(lints, Lint{
-				Message: "non-wrapping format verb for fmt.Errorf. Use `%w` to format errors",
-				Pos:     lintArg.Pos(),
-			})
-		}
 	}
 	return lints
 }

errorlint/testdata/src/fmterrorf-go1.19/github-36.go

@@ -0,0 +1,20 @@
+package issues
+
+import (
+	"errors"
+	"fmt"
+)
+
+func Single() error {
+	err1 := errors.New("oops1")
+	err2 := errors.New("oops2")
+	err3 := errors.New("oops3")
+	return fmt.Errorf("%w, %v, %v", err1, err2, err3)
+}
+
+func Multiple() error {
+	err1 := errors.New("oops1")
+	err2 := errors.New("oops2")
+	err3 := errors.New("oops3")
+	return fmt.Errorf("%w, %w, %w", err1, err2, err3) // want "only one %w verb is permitted per format string"
+}