accept async functions with testing.TB variant instead of Gomega

In Kubernetes' ktesting package the following assertion is valid:

    tCtx.Eventually(func(tCtx TContext) { /* maybe fail via tCtx */ }).Should(Succeed())

That works because tCtx.Eventually wraps the function such that failures
reported via tCtx.Error/Errorf/Fatal/Fatalf are visible to the matcher.

Without this change, the "Success matcher only support a single error value, or
function with Gomega as its first parameter" warning is triggered.

Instead of building in specific support for ktesting, the approach is to check
for a first parameter which has any (not necessarily all!) of the testing.TB
methods for reporting failures. That is considered a valid alternative to
a Gomega instance.

There's now a potential false negative in the linter when passing such a
function directly to gomega.Eventually/Consistently. That'll fail at runtime
because gomega cannot call it, so such a false negative isn't too bad (fails
reliably and obviously).

The warning message doesn't get changed because it would be confusing for most
users to call out some vague alternative (vague because the linter has no
details) that most users won't be able to use.

Author: pohly

internal/expression/actual/actualarg.go

@@ -29,6 +29,7 @@ const (
 	FuncSigArgType
 	ErrFuncActualArgType
 	GomegaParamArgType
+	TBParamArgType
 	MultiRetsArgType
 	ErrorMethodArgType
 

internal/expression/actual/asyncfuncarg.go

@@ -17,8 +17,13 @@ func getAsyncFuncArg(sig *gotypes.Signature) ArgPayload {
 
 	if sig.Params().Len() > 0 {
 		arg := sig.Params().At(0).Type()
-		if gomegainfo.IsGomegaType(arg) && sig.Results().Len() == 0 {
-			argType |= FuncSigArgType | GomegaParamArgType
+		if sig.Results().Len() == 0 {
+			if gomegainfo.IsGomegaType(arg) {
+				argType |= FuncSigArgType | GomegaParamArgType
+			}
+			if typecheck.ImplementsTB(arg) {
+				argType |= FuncSigArgType | TBParamArgType
+			}
 		}
 	}
 

internal/rules/asyncsucceedrule.go

@@ -17,14 +17,17 @@ func (AsyncSucceedRule) isApply(gexp *expression.GomegaExpression) bool {
 	return gexp.IsAsync() &&
 		gexp.MatcherTypeIs(matcher.SucceedMatcherType) &&
 		gexp.ActualArgTypeIs(actual.FuncSigArgType) &&
-		!gexp.ActualArgTypeIs(actual.ErrorTypeArgType|actual.GomegaParamArgType)
+		!gexp.ActualArgTypeIs(actual.ErrorTypeArgType|actual.GomegaParamArgType|actual.TBParamArgType)
 }
 
 func (r AsyncSucceedRule) Apply(gexp *expression.GomegaExpression, _ config.Config, reportBuilder *reports.Builder) bool {
 	if r.isApply(gexp) {
 		if gexp.ActualArgTypeIs(actual.MultiRetsArgType) {
 			reportBuilder.AddIssue(false, "Success matcher does not support multiple values")
 		} else {
+			// The message intentionally does not call out "function with a TB implementation" as another alternative because
+			// that alternative is not valid for generic Gomega - it would be confusing for many users. Users
+			// of a Gomega wrapper which supports such functions must figure that out themselves.
 			reportBuilder.AddIssue(false, "Success matcher only support a single error value, or function with Gomega as its first parameter")
 		}
 	}

internal/typecheck/interfaces.go

@@ -8,6 +8,16 @@ import (
 var (
 	errorType         *gotypes.Interface
 	gomegaMatcherType *gotypes.Interface
+	tbTypes           = []*gotypes.Interface{
+		// In practice, interfaces which mimick testing.TB probably implement
+		// more than one of these at the same time. But for ImplementsTB
+		// it's sufficient to have just one method which can be used
+		// to report a test failure.
+		tbInterface("Error", false),
+		tbInterface("Errorf", true),
+		tbInterface("Fatal", false),
+		tbInterface("Fatalf", true),
+	}
 )
 
 func init() {
@@ -76,3 +86,32 @@ func ImplementsError(t gotypes.Type) bool {
 func ImplementsGomegaMatcher(t gotypes.Type) bool {
 	return t != nil && gotypes.Implements(t, gomegaMatcherType)
 }
+
+// ImplementsTB checks if the argument type implements any of the methods in testing.TB which
+// can be used to report test failures. Such a type is a potential alternative to a Gomega
+// parameter in some Gomega wrappers.
+func ImplementsTB(t gotypes.Type) bool {
+	for _, tbType := range tbTypes {
+		if gotypes.Implements(t, tbType) {
+			return true
+		}
+	}
+	return false
+}
+
+// tbInterface generates an interface type with exactly one method
+// which has the given name and Printf or Println signature.
+func tbInterface(name string, printf bool) *gotypes.Interface {
+	var params []*gotypes.Var
+	if printf {
+		params = append(params, gotypes.NewVar(0, nil, "", gotypes.Typ[gotypes.String]))
+	}
+	params = append(params, gotypes.NewVar(0, nil, "", gotypes.NewSlice(gotypes.Universe.Lookup("any").Type())))
+	signature := gotypes.NewSignatureType(nil, nil, nil,
+		gotypes.NewTuple(params...),
+		gotypes.NewTuple(),
+		true,
+	)
+	method := gotypes.NewFunc(0, nil, name, signature)
+	return gotypes.NewInterfaceType([]*gotypes.Func{method}, nil)
+}

internal/typecheck/interfaces_test.go

@@ -0,0 +1,129 @@
+package typecheck
+
+import (
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	gotypes "go/types"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestImplementsTB(t *testing.T) {
+	src := `
+package main
+
+var (
+	NilInstance = any(nil)
+)
+
+type Error interface {
+	Error(args ...any)
+}
+
+type Errorf interface {
+	Errorf(fmt string, args ...any)
+}
+
+type Fatal interface {
+	Fatal(args ...any)
+}
+
+type Fatalf interface {
+	Fatalf(fmt string, args ...any)
+}
+
+type ErrorWrongArgs interface {
+	Error(fmt string, args ...any)
+}
+
+type ErrorfWrongArgs interface {
+	ErrorF(args ...any)
+}
+
+type FatalWrongArgs interface {
+	Fatal(fmt string, args ...any)
+}
+
+type FatalfWrongArgs interface {
+	Fatalf(args ...any)
+}
+`
+	pkg := mustTypecheck(src)
+
+	for name, expectResult := range map[string]bool{
+		"NilInstance":     false,
+		"Error":           true,
+		"Errorf":          true,
+		"Fatal":           true,
+		"Fatalf":          true,
+		"ErrorWrongArgs":  false,
+		"ErrorfWrongArgs": false,
+		"FatalWrongArgs":  false,
+		"FatalfWrongArgs": false,
+	} {
+		t.Run(name, func(t *testing.T) {
+			instance := pkg.Scope().Lookup(name)
+			if instance == nil {
+				t.Fatalf("%s not defined in source code", name)
+			}
+			actualResult := ImplementsTB(instance.Type())
+			if actualResult != expectResult {
+				t.Errorf("expected %v, got %v", expectResult, actualResult)
+			}
+		})
+	}
+}
+
+// The following code was copied from https://cs.opensource.google/go/go/+/refs/tags/go1.25.6:src/go/types/api_test.go;l=29-74;drc=34b70684ba2fc8c5cba900e9abdfb874c1bd8c0e
+// and slightly simplified.
+//
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the https://cs.opensource.google/go/go/+/refs/tags/go1.25.6:LICENSE
+
+func defaultImporter(fset *token.FileSet) gotypes.Importer {
+	return importer.ForCompiler(fset, runtime.Compiler, nil)
+}
+
+func mustParse(fset *token.FileSet, src string) *ast.File {
+	f, err := parser.ParseFile(fset, pkgName(src), src, parser.ParseComments)
+	if err != nil {
+		panic(err) // so we don't need to pass *testing.T
+	}
+	return f
+}
+
+func typecheck(src string) (*gotypes.Package, error) {
+	fset := token.NewFileSet()
+	f := mustParse(fset, src)
+	conf := &gotypes.Config{
+		Error:    func(error) {}, // collect all errors
+		Importer: defaultImporter(fset),
+	}
+	return conf.Check(f.Name.Name, fset, []*ast.File{f}, nil)
+}
+
+func mustTypecheck(src string) *gotypes.Package {
+	pkg, err := typecheck(src)
+	if err != nil {
+		panic(err) // so we don't need to pass *testing.T
+	}
+	return pkg
+}
+
+// pkgName extracts the package name from src, which must contain a package header.
+func pkgName(src string) string {
+	const kw = "package "
+	if i := strings.Index(src, kw); i >= 0 {
+		after := src[i+len(kw):]
+		n := len(after)
+		if i := strings.IndexAny(after, "\n\t ;/"); i >= 0 {
+			n = i
+		}
+		return after[:n]
+	}
+	panic("missing package header: " + src)
+}

testdata/src/a/eventually/eventuallyFunc.go

@@ -78,6 +78,12 @@ var _ = Describe("Eventually with function", func() {
 		Eventually(os.Getwd).Should(Equal("something"))   // valid
 		Eventually(os.Getwd()).Should(Equal("something")) // want `ginkgo-linter: use a function call in Eventually\. This actually checks nothing, because Eventually receives the function returned value, instead of function itself, and this value is never changed\. Consider using .Eventually\(os\.Getwd\)\.Should\(Equal\("something"\)\). instead`
 
+		Eventually(func(g Gomega) {}).Should(Succeed())
+		wrappers.MyEventually(func(tb wrappers.MyTB) {}).Should(Succeed())
+		Eventually(func() {}).Should(Succeed())            // want `ginkgo-linter: Success matcher only support a single error value, or function with Gomega as its first parameter`
+		wrappers.MyEventually(func() {}).Should(Succeed()) // want `ginkgo-linter: Success matcher only support a single error value, or function with Gomega as its first parameter`
+		wrappers.MyEventually(func(tb wrappers.MyTB) {}).Should(Succeed())
+
 		tst := test{}
 		Eventually(tst.slowInt).Should(Equal(42))                           // valid
 		Eventually(retMethod(tst)).Should(Equal(42))                        // valid. The function returns a method

testdata/src/a/eventually/eventuallyFunc.go.golden

@@ -78,7 +78,13 @@ var _ = Describe("Eventually with function", func() {
 		Eventually(os.Getwd).Should(Equal("something")) // valid
 		Eventually(os.Getwd).Should(Equal("something")) // want `ginkgo-linter: use a function call in Eventually\. This actually checks nothing, because Eventually receives the function returned value, instead of function itself, and this value is never changed\. Consider using .Eventually\(os\.Getwd\)\.Should\(Equal\("something"\)\). instead`
 
-		tst := test{}
+		Eventually(func(g Gomega) {}).Should(Succeed())
+		wrappers.MyEventually(func(tb wrappers.MyTB) {}).Should(Succeed())
+		Eventually(func() {}).Should(Succeed())            // want `ginkgo-linter: Success matcher only support a single error value, or function with Gomega as its first parameter`
+		wrappers.MyEventually(func() {}).Should(Succeed()) // want `ginkgo-linter: Success matcher only support a single error value, or function with Gomega as its first parameter`
+		wrappers.MyEventually(func(tb wrappers.MyTB) {}).Should(Succeed())
+
+                tst := test{}
 		Eventually(tst.slowInt).Should(Equal(42))                           // valid
 		Eventually(retMethod(tst)).Should(Equal(42))                        // valid. The function returns a method
 		Eventually(tst.slowInt).Should(Equal(42))                           // want `ginkgo-linter: use a function call in Eventually\. This actually checks nothing, because Eventually receives the function returned value, instead of function itself, and this value is never changed\. Consider using .Eventually\(tst\.slowInt\)\.Should\(Equal\(42\)\). instead`

testdata/src/a/wrappers/wrappers.go

@@ -1,17 +1,30 @@
 package wrappers
 
 import (
+	"testing"
+
 	gtypes "github.com/onsi/gomega/types"
 
 	g "github.com/onsi/gomega"
 )
 
+type MyTB interface {
+	Error(args ...any)
+	Errorf(format string, args ...any)
+	Fatal(args ...any)
+	Fatalf(format string, args ...any)
+}
+
+var _ MyTB = &testing.T{}
+var _ MyTB = &testing.B{}
+
 var Expect = g.Expect
 
 func MyExpect(value any) g.Assertion {
 	return g.Expect(value)
 }
 
+// value = func(tb MyTB) without return value is okay, failures can be reported via tb.Error/Fatal/Errorf/Fatalf.
 func MyEventually(value any) g.AsyncAssertion {
 	return g.Eventually(value)
 }