gopls/internal/analysis/modernize: replace WithCancel with t.Cancel

This CL adds a modernizer to replace calls to context.WithCancel with
calls to t.Cancel, where t is the *testing.T (or B, or F) for the
relevant surrounding test function.

Example:

func TestFoo(t *testing.T) {
  ctx, cancel := context.WithCancel(context.Background())
  defer cancel

  ...
}

=>

func TestFoo(t *testing.T) {
  ctx := t.Context()
}

Also, factor out an analysisinternal.IsPointerNamed helper to assist
with identifying pointers to named types. This slightly alters the
behavior of the bloop pass, as it was previously tolerant implicitly
referenced testing.B variables, but that seems unimportant.

Updates golang/go#70815

Change-Id: Id10b5feb85a43e71d5ad740198d27135e8a3e6cf
Reviewed-on: https://go-review.googlesource.com/c/tools/+/641440
Auto-Submit: Robert Findley <rfindley@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

Author: findleyr

gopls/doc/analyzers.md

@@ -480,6 +480,8 @@ existing code by using more modern features of Go, such as:
     from the maps package, added in go1.21;
   - replacing []byte(fmt.Sprintf...) by fmt.Appendf(nil, ...),
     added in go1.19;
+  - replacing uses of context.WithCancel in tests with t.Context, added in
+    go1.24;
 
 Default: on.
 

gopls/internal/analysis/modernize/bloop.go

@@ -16,7 +16,6 @@ import (
 	"golang.org/x/tools/go/types/typeutil"
 	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/astutil/cursor"
-	"golang.org/x/tools/internal/typesinternal"
 )
 
 // bloop updates benchmarks that use "for range b.N", replacing it
@@ -90,7 +89,7 @@ func bloop(pass *analysis.Pass) {
 				if cmp, ok := n.Cond.(*ast.BinaryExpr); ok && cmp.Op == token.LSS {
 					if sel, ok := cmp.Y.(*ast.SelectorExpr); ok &&
 						sel.Sel.Name == "N" &&
-						isTestingB(info.TypeOf(sel.X)) {
+						analysisinternal.IsPointerToNamed(info.TypeOf(sel.X), "testing", "B") {
 
 						delStart, delEnd := n.Cond.Pos(), n.Cond.End()
 
@@ -133,7 +132,7 @@ func bloop(pass *analysis.Pass) {
 					n.Key == nil &&
 					n.Value == nil &&
 					sel.Sel.Name == "N" &&
-					isTestingB(info.TypeOf(sel.X)) {
+					analysisinternal.IsPointerToNamed(info.TypeOf(sel.X), "testing", "B") {
 
 					pass.Report(analysis.Diagnostic{
 						// Highlight "range b.N".
@@ -152,10 +151,6 @@ func bloop(pass *analysis.Pass) {
 	}
 }
 
-func isTestingB(t types.Type) bool {
-	return analysisinternal.IsTypeNamed(typesinternal.Unpointer(t), "testing", "B")
-}
-
 // uses reports whether the subtree cur contains a use of obj.
 func uses(info *types.Info, cur cursor.Cursor, obj types.Object) bool {
 	for curId := range cur.Preorder((*ast.Ident)(nil)) {

gopls/internal/analysis/modernize/doc.go

@@ -23,4 +23,6 @@
 //     from the maps package, added in go1.21;
 //   - replacing []byte(fmt.Sprintf...) by fmt.Appendf(nil, ...),
 //     added in go1.19;
+//   - replacing uses of context.WithCancel in tests with t.Context, added in
+//     go1.24;
 package modernize

gopls/internal/analysis/modernize/modernize.go

@@ -63,6 +63,7 @@ func run(pass *analysis.Pass) (any, error) {
 	mapsloop(pass)
 	minmax(pass)
 	sortslice(pass)
+	testingContext(pass)
 
 	// TODO(adonovan):
 	// - more modernizers here; see #70815.

gopls/internal/analysis/modernize/modernize_test.go

@@ -20,5 +20,6 @@ func Test(t *testing.T) {
 		"mapsloop",
 		"minmax",
 		"sortslice",
+		"testingcontext",
 	)
 }

gopls/internal/analysis/modernize/testdata/src/testingcontext/testingcontext.go

@@ -0,0 +1 @@
+package testingcontext

gopls/internal/analysis/modernize/testdata/src/testingcontext/testingcontext_test.go

@@ -0,0 +1,78 @@
+package testingcontext
+
+import (
+	"context"
+
+	"testing"
+)
+
+func Test(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background()) // want "context.WithCancel can be modernized using t.Context"
+	defer cancel()
+	_ = ctx
+
+	func() {
+		ctx, cancel := context.WithCancel(context.Background()) // Nope. scope of defer is not the testing func.
+		defer cancel()
+		_ = ctx
+	}()
+
+	{
+		ctx, cancel := context.WithCancel(context.TODO()) // want "context.WithCancel can be modernized using t.Context"
+		defer cancel()
+		_ = ctx
+		var t int // not in scope of the call to WithCancel
+		_ = t
+	}
+
+	{
+		ctx := context.Background()
+		ctx, cancel := context.WithCancel(context.Background()) // Nope. ctx is redeclared.
+		defer cancel()
+		_ = ctx
+	}
+
+	{
+		var t int
+		ctx, cancel := context.WithCancel(context.Background()) // Nope. t is shadowed.
+		defer cancel()
+		_ = ctx
+		_ = t
+	}
+
+	t.Run("subtest", func(t2 *testing.T) {
+		ctx, cancel := context.WithCancel(context.Background()) // want "context.WithCancel can be modernized using t2.Context"
+		defer cancel()
+		_ = ctx
+	})
+}
+
+func TestAlt(t2 *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background()) // want "context.WithCancel can be modernized using t2.Context"
+	defer cancel()
+	_ = ctx
+}
+
+func Testnot(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background()) // Nope. Not a test func.
+	defer cancel()
+	_ = ctx
+}
+
+func Benchmark(b *testing.B) {
+	ctx, cancel := context.WithCancel(context.Background()) // want "context.WithCancel can be modernized using b.Context"
+	defer cancel()
+	_ = ctx
+
+	b.Run("subtest", func(b2 *testing.B) {
+		ctx, cancel := context.WithCancel(context.Background()) // want "context.WithCancel can be modernized using b2.Context"
+		defer cancel()
+		_ = ctx
+	})
+}
+
+func Fuzz(f *testing.F) {
+	ctx, cancel := context.WithCancel(context.Background()) // want "context.WithCancel can be modernized using f.Context"
+	defer cancel()
+	_ = ctx
+}

gopls/internal/analysis/modernize/testdata/src/testingcontext/testingcontext_test.go.golden

@@ -0,0 +1,71 @@
+package testingcontext
+
+import (
+	"context"
+
+	"testing"
+)
+
+func Test(t *testing.T) {
+	ctx := t.Context()
+	_ = ctx
+
+	func() {
+		ctx, cancel := context.WithCancel(context.Background()) // Nope. scope of defer is not the testing func.
+		defer cancel()
+		_ = ctx
+	}()
+
+	{
+		ctx := t.Context()
+		_ = ctx
+		var t int // not in scope of the call to WithCancel
+		_ = t
+	}
+
+	{
+		ctx := context.Background()
+		ctx, cancel := context.WithCancel(context.Background()) // Nope. ctx is redeclared.
+		defer cancel()
+		_ = ctx
+	}
+
+	{
+		var t int
+		ctx, cancel := context.WithCancel(context.Background()) // Nope. t is shadowed.
+		defer cancel()
+		_ = ctx
+		_ = t
+	}
+
+	t.Run("subtest", func(t2 *testing.T) {
+		ctx := t2.Context()
+		_ = ctx
+	})
+}
+
+func TestAlt(t2 *testing.T) {
+	ctx := t2.Context()
+	_ = ctx
+}
+
+func Testnot(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background()) // Nope. Not a test func.
+	defer cancel()
+	_ = ctx
+}
+
+func Benchmark(b *testing.B) {
+	ctx := b.Context()
+	_ = ctx
+
+	b.Run("subtest", func(b2 *testing.B) {
+		ctx := b2.Context()
+		_ = ctx
+	})
+}
+
+func Fuzz(f *testing.F) {
+	ctx := f.Context()
+	_ = ctx
+}