[pre-commit.ci] pre-commit autoupdate

updates:
- [github.com/golangci/golangci-lint: v1.64.6 → v1.64.7](https://github.com/golangci/golangci-lint/compare/v1.64.6...v1.64.7)

.github/dependabot.yml

@@ -6,6 +6,10 @@ updates:
     directory: "/"
     schedule:
       interval: "monthly"
+    groups:
+      github-actions:
+        patterns:
+          - "*"  # Group all updates into a single larger pull request.
   - package-ecosystem: "gomod"
     directory: "/"
     schedule:

.github/workflows/go.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: ['1.22', '1.23']
+        go: [stable, oldstable]
         os: [macos-latest, windows-latest, ubuntu-latest]
     name: build
     runs-on: ${{ matrix.os }}

.github/workflows/golangci-lint.yml

@@ -16,7 +16,7 @@ jobs:
   golangci:
     strategy:
       matrix:
-        go: ['1.22', '1.23']
+        go: [stable, oldstable]
     name: lint
     runs-on: ubuntu-latest
     steps:

.github/workflows/goreleaser.yml

@@ -17,6 +17,8 @@ jobs:
           fetch-depth: 0
       - name: Set up Go
         uses: actions/setup-go@v5
+        with:
+          go-version: stable
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v6
         with:

.pre-commit-config.yaml

@@ -9,7 +9,7 @@ repos:
       - id: end-of-file-fixer
       - id: trailing-whitespace
   - repo: https://github.com/golangci/golangci-lint
-    rev: v1.63.4
+    rev: v1.64.7
     hooks:
       - id: golangci-lint-full
   - repo: local

go.mod

@@ -2,9 +2,9 @@ module github.com/Crocmagnon/fatcontext
 
 go 1.22.0
 
-require golang.org/x/tools v0.28.0
+require golang.org/x/tools v0.30.0
 
 require (
-	golang.org/x/mod v0.22.0 // indirect
-	golang.org/x/sync v0.10.0 // indirect
+	golang.org/x/mod v0.23.0 // indirect
+	golang.org/x/sync v0.11.0 // indirect
 )

go.sum

@@ -1,8 +1,8 @@
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
-golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
-golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
-golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/tools v0.28.0 h1:WuB6qZ4RPCQo5aP3WdKZS7i595EdWqWR8vqJTlwTVK8=
-golang.org/x/tools v0.28.0/go.mod h1:dcIOrVd3mfQKTgrDVQHqCPMWy6lnhfhtX3hLXYVLfRw=
+golang.org/x/mod v0.23.0 h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM=
+golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/tools v0.30.0 h1:BgcpHewrV5AUp2G9MebG4XPFI1E2W41zU1SaqVA9vJY=
+golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY=

pkg/analyzer/analyzer.go

@@ -62,6 +62,10 @@ func (r *runner) run(pass *analysis.Pass) (interface{}, error) {
 			return
 		}
 
+		if body == nil {
+			return
+		}
+
 		assignStmt := findNestedContext(pass, node, body.List)
 		if assignStmt == nil {
 			return

pkg/analyzer/analyzer_test.go

@@ -1,8 +1,6 @@
 package analyzer_test
 
 import (
-	"os"
-	"path/filepath"
 	"testing"
 
 	"golang.org/x/tools/go/analysis/analysistest"
@@ -11,27 +9,55 @@ import (
 )
 
 func TestAnalyzer(t *testing.T) {
-	wd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("Failed to get wd: %s", err)
+	testCases := []struct {
+		desc    string
+		dir     string
+		options map[string]string
+	}{
+		{
+			desc: "no func decl",
+			dir:  "common",
+		},
+		{
+			desc: "no func decl",
+			dir:  "no_structpointer",
+		},
+		{
+			desc: "func decl",
+			dir:  "common",
+			options: map[string]string{
+				analyzer.FlagCheckStructPointers: "true",
+			},
+		},
+		{
+			desc: "func decl",
+			dir:  "structpointer",
+			options: map[string]string{
+				analyzer.FlagCheckStructPointers: "true",
+			},
+		},
 	}
-	testdata := filepath.Join(wd, "testdata")
 
-	t.Run("no func decl", func(t *testing.T) {
-		an := analyzer.NewAnalyzer()
-		analysistest.Run(t, testdata, an, "./common")
-		analysistest.Run(t, testdata, an, "./no_structpointer")
-	})
+	for _, test := range testCases {
+		t.Run(test.desc+"_"+test.dir, func(t *testing.T) {
+			t.Parallel()
 
-	t.Run("func decl", func(t *testing.T) {
-		an := analyzer.NewAnalyzer()
+			a := analyzer.NewAnalyzer()
 
-		err := an.Flags.Set(analyzer.FlagCheckStructPointers, "true")
-		if err != nil {
-			t.Fatal(err)
-		}
+			for k, v := range test.options {
+				err := a.Flags.Set(k, v)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
 
-		analysistest.Run(t, testdata, an, "./common")
-		analysistest.Run(t, testdata, an, "./structpointer")
-	})
+			analysistest.RunWithSuggestedFixes(t, analysistest.TestData(), a, test.dir)
+		})
+	}
+}
+
+func TestAnalyzer_cgo(t *testing.T) {
+	a := analyzer.NewAnalyzer()
+
+	analysistest.Run(t, analysistest.TestData(), a, "cgo")
 }

pkg/analyzer/testdata/src/cgo/cgo.go

@@ -0,0 +1,51 @@
+package cgo
+
+/*
+ #include <stdio.h>
+ #include <stdlib.h>
+
+ void myprint(char* s) {
+ 	printf("%d\n", s);
+ }
+*/
+import "C"
+
+import (
+	"context"
+	"unsafe"
+)
+
+func _() {
+	cs := C.CString("Hello from stdio\n")
+	C.myprint(cs)
+	C.free(unsafe.Pointer(cs))
+}
+
+func _() {
+	ctx := context.Background()
+
+	for i := 0; i < 10; i++ {
+		ctx := context.WithValue(ctx, "key", i)
+		ctx = context.WithValue(ctx, "other", "val")
+	}
+
+	for i := 0; i < 10; i++ {
+		ctx = context.WithValue(ctx, "key", i) // want "nested context in loop"
+		ctx = context.WithValue(ctx, "other", "val")
+	}
+
+	for item := range []string{"one", "two", "three"} {
+		ctx = wrapContext(ctx) // want "nested context in loop"
+		ctx := context.WithValue(ctx, "key", item)
+		ctx = wrapContext(ctx)
+	}
+
+	for {
+		ctx = wrapContext(ctx) // want "nested context in loop"
+		break
+	}
+}
+
+func wrapContext(ctx context.Context) context.Context {
+	return context.WithoutCancel(ctx)
+}

pkg/analyzer/testdata/src/common/example.go.golden

@@ -0,0 +1,251 @@
+package common
+
+import (
+	"context"
+	"testing"
+)
+
+func example() {
+	ctx := context.Background()
+
+	for i := 0; i < 10; i++ {
+		ctx := context.WithValue(ctx, "key", i)
+		ctx = context.WithValue(ctx, "other", "val")
+	}
+
+	for i := 0; i < 10; i++ {
+		ctx := context.WithValue(ctx, "key", i) // want "nested context in loop"
+		ctx = context.WithValue(ctx, "other", "val")
+	}
+
+	for item := range []string{"one", "two", "three"} {
+		ctx := wrapContext(ctx) // want "nested context in loop"
+		ctx := context.WithValue(ctx, "key", item)
+		ctx = wrapContext(ctx)
+	}
+
+	for {
+		ctx := wrapContext(ctx) // want "nested context in loop"
+		break
+	}
+
+	// not fooled by shadowing in nested blocks
+	for {
+		err := doSomething()
+		if err != nil {
+			ctx := wrapContext(ctx)
+			ctx = wrapContext(ctx)
+		}
+
+		switch err {
+		case nil:
+			ctx := wrapContext(ctx)
+			ctx = wrapContext(ctx)
+		default:
+			ctx := wrapContext(ctx)
+			ctx = wrapContext(ctx)
+		}
+
+		{
+			ctx := wrapContext(ctx)
+			ctx = wrapContext(ctx)
+		}
+
+		select {
+		case <-ctx.Done():
+			ctx := wrapContext(ctx)
+			ctx = wrapContext(ctx)
+		default:
+		}
+
+		ctx := wrapContext(ctx) // want "nested context in loop"
+
+		break
+	}
+
+	// detects contexts wrapped in function literals (this is risky as function literals can be called multiple times)
+	_ = func() {
+		ctx := wrapContext(ctx) // want "nested context in function literal"
+	}
+
+	// this is fine because the context is created in the loop
+	for {
+		if ctx := context.Background(); doSomething() != nil {
+			ctx = wrapContext(ctx)
+		}
+	}
+
+	for {
+		ctx2 := context.Background()
+		ctx := wrapContext(ctx) // want "nested context in loop"
+		if doSomething() != nil {
+			ctx2 = wrapContext(ctx2)
+		}
+	}
+}
+
+func wrapContext(ctx context.Context) context.Context {
+	return context.WithoutCancel(ctx)
+}
+
+func doSomething() error {
+	return nil
+}
+
+// storing contexts in a struct isn't recommended, but local copies of a non-pointer struct should act like local copies of a context.
+func inStructs(ctx context.Context) {
+	for i := 0; i < 10; i++ {
+		c := struct{ Ctx context.Context }{ctx}
+		c.Ctx = context.WithValue(c.Ctx, "key", i)
+		c.Ctx = context.WithValue(c.Ctx, "other", "val")
+	}
+
+	for i := 0; i < 10; i++ {
+		c := []struct{ Ctx context.Context }{{ctx}}
+		c[0].Ctx = context.WithValue(c[0].Ctx, "key", i)
+		c[0].Ctx = context.WithValue(c[0].Ctx, "other", "val")
+	}
+
+	c := struct{ Ctx context.Context }{ctx}
+	for i := 0; i < 10; i++ {
+		c := c
+		c.Ctx = context.WithValue(c.Ctx, "key", i)
+		c.Ctx = context.WithValue(c.Ctx, "other", "val")
+	}
+
+	pc := &struct{ Ctx context.Context }{ctx}
+	for i := 0; i < 10; i++ {
+		c := pc
+		c.Ctx := context.WithValue(c.Ctx, "key", i) // want "nested context in loop"
+		c.Ctx = context.WithValue(c.Ctx, "other", "val")
+	}
+
+	r := []struct{ Ctx context.Context }{{ctx}}
+	for i := 0; i < 10; i++ {
+		r[0].Ctx := context.WithValue(r[0].Ctx, "key", i) // want "nested context in loop"
+		r[0].Ctx = context.WithValue(r[0].Ctx, "other", "val")
+	}
+
+	rp := []*struct{ Ctx context.Context }{{ctx}}
+	for i := 0; i < 10; i++ {
+		rp[0].Ctx := context.WithValue(rp[0].Ctx, "key", i) // want "nested context in loop"
+		rp[0].Ctx = context.WithValue(rp[0].Ctx, "other", "val")
+	}
+}
+
+func inVariousNestedBlocks(ctx context.Context) {
+	for {
+		err := doSomething()
+		if err != nil {
+			ctx := wrapContext(ctx) // want "nested context in loop"
+		}
+
+		break
+	}
+
+	for {
+		err := doSomething()
+		if err != nil {
+			if true {
+				ctx := wrapContext(ctx) // want "nested context in loop"
+			}
+		}
+
+		break
+	}
+
+	for {
+		err := doSomething()
+		switch err {
+		case nil:
+			ctx := wrapContext(ctx) // want "nested context in loop"
+		}
+
+		break
+	}
+
+	for {
+		err := doSomething()
+		switch err {
+		default:
+			ctx := wrapContext(ctx) // want "nested context in loop"
+		}
+
+		break
+	}
+
+	for {
+		ctx := wrapContext(ctx)
+
+		err := doSomething()
+		if err != nil {
+			ctx = wrapContext(ctx)
+		}
+
+		break
+	}
+
+	for {
+		{
+			ctx := wrapContext(ctx) // want "nested context in loop"
+		}
+
+		break
+	}
+
+	for {
+		select {
+		case <-ctx.Done():
+			ctx := wrapContext(ctx) // want "nested context in loop"
+		default:
+		}
+
+		break
+	}
+}
+
+// this middleware could run on every request, bloating the request parameter level context and causing a memory leak
+func badMiddleware(ctx context.Context) func() error {
+	return func() error {
+		ctx := wrapContext(ctx) // want "nested context in function literal"
+		return doSomethingWithCtx(ctx)
+	}
+}
+
+// this middleware is fine, as it doesn't modify the context of parent function
+func okMiddleware(ctx context.Context) func() error {
+	return func() error {
+		ctx := wrapContext(ctx)
+		return doSomethingWithCtx(ctx)
+	}
+}
+
+// this middleware is fine, as it only modifies the context passed to it
+func okMiddleware2(ctx context.Context) func(ctx context.Context) error {
+	return func(ctx context.Context) error {
+		ctx = wrapContext(ctx)
+		return doSomethingWithCtx(ctx)
+	}
+}
+
+func doSomethingWithCtx(ctx context.Context) error {
+	return nil
+}
+
+func testCasesInit(t *testing.T) {
+	cases := []struct {
+		ctx context.Context
+	}{
+		{},
+		{
+			ctx: context.WithValue(context.Background(), "key", "value"),
+		},
+	}
+	for _, tc := range cases {
+		t.Run("some test", func(t *testing.T) {
+			if tc.ctx == nil {
+				tc.ctx = context.Background()
+			}
+		})
+	}
+}