feat: add file filtering options for test and generated files (#3)

* feat: add file filtering options for test and generated files

- Add -test flag (default: true) to control analysis of *_test.go files
- Auto-exclude generated files (// Code generated ... DO NOT EDIT.) using ast.IsGenerated
- Generated files are always excluded (no opt-out)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* test: add tests and docs for file filtering options

- Add TestFileFilterDefault: verify generated files are skipped, test files analyzed by default
- Add TestFileFilterSkipTests: verify test files skipped when -test=false
- Add testdata fixtures for filefilter and filefilterskip packages
- Document -test flag and generated file exclusion in README.md

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: mpyw

README.md

@@ -364,6 +364,22 @@ Available flags:
 - `-spawnerlabel` (default: false) - Check that spawner functions are properly labeled
 - `-gotask` (default: true, requires `-goroutine-deriver`)
 
+### File Filtering
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `-test` | `true` | Analyze test files (`*_test.go`) |
+
+Generated files (containing `// Code generated ... DO NOT EDIT.`) are always excluded and cannot be opted in.
+
+```bash
+# Exclude test files from analysis
+goroutinectx -test=false ./...
+
+# With go vet
+go vet -vettool=$(which goroutinectx) -goroutinectx.test=false ./...
+```
+
 ### `-spawnerlabel`
 
 When enabled, checks that functions calling spawn methods with func arguments have the `//goroutinectx:spawner` directive:

analyzer.go

@@ -39,6 +39,9 @@ var (
 	enableSpawner      bool
 	enableSpawnerlabel bool
 	enableGotask       bool
+
+	// File filtering flags.
+	analyzeTests bool
 )
 
 func init() {
@@ -56,6 +59,9 @@ func init() {
 	Analyzer.Flags.BoolVar(&enableSpawner, "spawner", true, "enable spawner checker")
 	Analyzer.Flags.BoolVar(&enableSpawnerlabel, "spawnerlabel", false, "enable spawnerlabel checker")
 	Analyzer.Flags.BoolVar(&enableGotask, "gotask", true, "enable gotask checker (requires -goroutine-deriver)")
+
+	// File filtering flags
+	Analyzer.Flags.BoolVar(&analyzeTests, "test", true, "analyze test files (*_test.go)")
 }
 
 // Analyzer is the main analyzer for goroutinectx.
@@ -75,11 +81,14 @@ func run(pass *analysis.Pass) (any, error) {
 		return nil, ErrNoInspector
 	}
 
+	// Build set of files to skip
+	skipFiles := buildSkipFiles(pass)
+
 	// Parse configuration
 	carriers := carrier.Parse(contextCarriers)
 
-	// Build ignore maps for each file
-	ignoreMaps := buildIgnoreMaps(pass)
+	// Build ignore maps for each file (excluding skipped files)
+	ignoreMaps := buildIgnoreMaps(pass, skipFiles)
 
 	// Build spawner map from //goroutinectx:spawner directives and -external-spawner flag
 	spawners := spawnerdir.Build(pass, externalSpawner)
@@ -88,12 +97,12 @@ func run(pass *analysis.Pass) (any, error) {
 	enabled := buildEnabledCheckers(spawners)
 
 	// Run AST-based checks (goroutine, errgroup, waitgroup)
-	runASTChecks(pass, insp, ignoreMaps, carriers, spawners)
+	runASTChecks(pass, insp, ignoreMaps, carriers, spawners, skipFiles)
 
 	// Run spawnerlabel checker if enabled
 	if enableSpawnerlabel {
 		spawnerlabelChecker := spawnerlabel.New(spawners)
-		spawnerlabelChecker.Check(pass, ignoreMaps)
+		spawnerlabelChecker.Check(pass, ignoreMaps, skipFiles)
 	}
 
 	// Report unused ignore directives
@@ -102,12 +111,39 @@ func run(pass *analysis.Pass) (any, error) {
 	return nil, nil
 }
 
+// buildSkipFiles creates a set of filenames to skip based on flags.
+// Generated files are always skipped.
+// Test files are skipped when analyzeTests is false.
+func buildSkipFiles(pass *analysis.Pass) map[string]bool {
+	skipFiles := make(map[string]bool)
+
+	for _, file := range pass.Files {
+		filename := pass.Fset.Position(file.Pos()).Filename
+
+		// Always skip generated files
+		if ast.IsGenerated(file) {
+			skipFiles[filename] = true
+			continue
+		}
+
+		// Skip test files if -test=false
+		if !analyzeTests && strings.HasSuffix(filename, "_test.go") {
+			skipFiles[filename] = true
+		}
+	}
+
+	return skipFiles
+}
+
 // buildIgnoreMaps creates ignore maps for each file in the pass.
-func buildIgnoreMaps(pass *analysis.Pass) map[string]ignore.Map {
+func buildIgnoreMaps(pass *analysis.Pass, skipFiles map[string]bool) map[string]ignore.Map {
 	ignoreMaps := make(map[string]ignore.Map)
 
 	for _, file := range pass.Files {
 		filename := pass.Fset.Position(file.Pos()).Filename
+		if skipFiles[filename] {
+			continue
+		}
 		ignoreMaps[filename] = ignore.Build(pass.Fset, file)
 	}
 
@@ -121,6 +157,7 @@ func runASTChecks(
 	ignoreMaps map[string]ignore.Map,
 	carriers []carrier.Carrier,
 	spawners *spawnerdir.Map,
+	skipFiles map[string]bool,
 ) {
 	// Build context scopes for functions with context parameters
 	funcScopes := buildFuncScopes(pass, insp, carriers)
@@ -171,12 +208,16 @@ func runASTChecks(
 			return true
 		}
 
+		filename := pass.Fset.Position(n.Pos()).Filename
+		if skipFiles[filename] {
+			return true
+		}
+
 		scope := findEnclosingScope(funcScopes, stack)
 		if scope == nil {
 			return true // No context in scope
 		}
 
-		filename := pass.Fset.Position(n.Pos()).Filename
 		cctx := &context.CheckContext{
 			Pass:      pass,
 			Scope:     scope,

analyzer_test.go

@@ -131,3 +131,24 @@ func TestGotask(t *testing.T) {
 
 	analysistest.Run(t, testdata, goroutinectx.Analyzer, "gotask")
 }
+
+func TestFileFilterDefault(t *testing.T) {
+	testdata := analysistest.TestData()
+	// Default: -test=true, so test files are analyzed
+	analysistest.Run(t, testdata, goroutinectx.Analyzer, "filefilter")
+}
+
+func TestFileFilterSkipTests(t *testing.T) {
+	testdata := analysistest.TestData()
+
+	// Set -test=false to skip test files
+	if err := goroutinectx.Analyzer.Flags.Set("test", "false"); err != nil {
+		t.Fatal(err)
+	}
+
+	defer func() {
+		_ = goroutinectx.Analyzer.Flags.Set("test", "true")
+	}()
+
+	analysistest.Run(t, testdata, goroutinectx.Analyzer, "filefilterskip")
+}

internal/checkers/spawnerlabel/checker.go

@@ -23,9 +23,12 @@ func New(spawners *spawner.Map) *Checker {
 }
 
 // Check runs the spawnerlabel analysis on the given pass.
-func (c *Checker) Check(pass *analysis.Pass, ignoreMaps map[string]ignore.Map) {
+func (c *Checker) Check(pass *analysis.Pass, ignoreMaps map[string]ignore.Map, skipFiles map[string]bool) {
 	for _, file := range pass.Files {
 		filename := pass.Fset.Position(file.Pos()).Filename
+		if skipFiles[filename] {
+			continue
+		}
 		ignoreMap := ignoreMaps[filename]
 
 		for _, decl := range file.Decls {

testdata/metatest/options.json

@@ -1,6 +1,8 @@
 {
   "excludeDirs": [
     "github.com",
-    "golang.org"
+    "golang.org",
+    "filefilter",
+    "filefilterskip"
   ]
 }

testdata/src/filefilter/code_test.go

@@ -0,0 +1,13 @@
+package filefilter
+
+import (
+	"context"
+	"fmt"
+)
+
+// badGoroutineInTest is reported when -test=true (default).
+func badGoroutineInTest(ctx context.Context) {
+	go func() { // want `goroutine does not propagate context "ctx"`
+		fmt.Println("no context in test file")
+	}()
+}

testdata/src/filefilter/generated.go

@@ -0,0 +1,24 @@
+// Package filefilter tests file filtering functionality.
+// Tests that:
+// - Generated files are always skipped (see generated.go)
+// - Test files are analyzed by default (see code_test.go)
+package filefilter
+
+import (
+	"context"
+	"fmt"
+)
+
+// badGoroutine should be reported in regular files.
+func badGoroutine(ctx context.Context) {
+	go func() { // want `goroutine does not propagate context "ctx"`
+		fmt.Println("no context")
+	}()
+}
+
+// goodGoroutine properly uses context.
+func goodGoroutine(ctx context.Context) {
+	go func() {
+		_ = ctx
+	}()
+}

testdata/src/filefilter/main.go

@@ -0,0 +1,13 @@
+package filefilterskip
+
+import (
+	"context"
+	"fmt"
+)
+
+// badGoroutineInTest is NOT reported when -test=false.
+func badGoroutineInTest(ctx context.Context) {
+	go func() {
+		fmt.Println("no context in test file - but skipped")
+	}()
+}