From c8fabc785503ea55d93fe05a907ebb59eb79f59f Mon Sep 17 00:00:00 2001 From: Nathan Nutter Date: Tue, 17 Nov 2026 12:54:02 -0600 Subject: [PATCH 1/6] Ignore the ambient Git directory when checking fixes git rebase --exec exports GIT_DIR for the repository being rebased and an empty GIT_PREFIX. Git treats both as stronger than -C, so fixture setup runs git init against that repository. On a linked worktree, init sets core.bare and later Git commands refuse to run. Drop those variables for fixture Git commands and for the clean-tree check. The directory passed to Git is the repository those commands mean, including while the suite runs under rebase --exec. Change-Id: Ibde05b64cb34eb32a26fcd7d150b418044edfd3e --- internal/driver/ambient_git_test.go | 55 +++++++++++++++++++++++++++++ internal/driver/fix.go | 25 +++++++++++++ internal/driver/fix_test.go | 5 +-- internal/driver/git_command_test.go | 48 +++++++++++++++++++++++++ internal/driver/git_safety_test.go | 5 +-- internal/driver/iterate_test.go | 12 +++---- 6 files changed, 134 insertions(+), 16 deletions(-) create mode 100644 internal/driver/ambient_git_test.go create mode 100644 internal/driver/git_command_test.go diff --git a/internal/driver/ambient_git_test.go b/internal/driver/ambient_git_test.go new file mode 100644 index 0000000..c98f822 --- /dev/null +++ b/internal/driver/ambient_git_test.go @@ -0,0 +1,55 @@ +package driver_test + +import ( + "os" + "path/filepath" + "strings" + "testing" + + "github.com/stretchr/testify/require" + "golang.org/x/tools/go/analysis" + + "github.com/nnutter/constable/internal/driver" +) + +// git rebase --exec exports GIT_DIR for the repository being rebased. Git +// treats that variable as stronger than -C, so fixture setup must not follow it. +func TestFixLeavesAmbientRepositoryUntouched(t *testing.T) { + outer := t.TempDir() + runGit(t, outer, "init", "-q") + runGit(t, outer, "config", "user.email", "keep@example.com") + runGit(t, outer, "config", "user.name", "Keep") + require.NoError(t, os.WriteFile(filepath.Join(outer, "keep.txt"), []byte("keep\n"), 0o644)) + runGit(t, outer, "add", ".") + runGit(t, outer, "commit", "-qm", "keep") + worktree := t.TempDir() + runGit(t, outer, "worktree", "add", "--detach", "-q", worktree) + common := strings.TrimSpace(runGit(t, worktree, "rev-parse", "--path-format=absolute", "--git-common-dir")) + gitDir := strings.TrimSpace(runGit(t, worktree, "rev-parse", "--absolute-git-dir")) + configPath := filepath.Join(common, "config") + before, err := os.ReadFile(configPath) + require.NoError(t, err) + + t.Setenv("GIT_DIR", gitDir) + t.Setenv("GIT_PREFIX", "") + + dir := t.TempDir() + require.NoError(t, os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module example.com/fix\n\ngo 1.25\n"), 0o644)) + require.NoError(t, os.WriteFile(filepath.Join(dir, "a.go"), []byte("package fix\nfunc a() { Broken := 1; _ = Broken }\n"), 0o644)) + runGit(t, dir, "init", "-q") + runGit(t, dir, "config", "user.email", "test@example.com") + runGit(t, dir, "config", "user.name", "Test") + runGit(t, dir, "add", ".") + runGit(t, dir, "commit", "-qm", "initial") + t.Chdir(dir) + code := driver.Run([]string{"."}, []*analysis.Analyzer{fixAnalyzer("", false, false, false)}, driver.Options{Fix: true, Context: -1}) + require.Equal(t, 0, code) + after, err := os.ReadFile("a.go") + require.NoError(t, err) + require.Contains(t, string(after), "Fixed") + + config, err := os.ReadFile(configPath) + require.NoError(t, err) + require.Equal(t, string(before), string(config)) + runGit(t, worktree, "status", "--porcelain") +} diff --git a/internal/driver/fix.go b/internal/driver/fix.go index 15156b0..b167140 100644 --- a/internal/driver/fix.go +++ b/internal/driver/fix.go @@ -176,6 +176,8 @@ func checkGitClean(name string) error { pathspec := ":(literal)" + base git := func(args ...string) ([]byte, error) { cmd := exec.Command("git", append([]string{"--no-optional-locks", "-C", dir}, args...)...) // #nosec G204 -- The path is passed as a literal Git pathspec. + // -C selects the file's repository. GIT_DIR from git rebase --exec would override it. + cmd.Env = gitEnvWithoutRepository(os.Environ()) return cmd.Output() } tracked, err := git("ls-files", "-v", "-z", "--", pathspec) @@ -203,6 +205,29 @@ func checkGitClean(name string) error { return nil } +// git rebase --exec exports GIT_DIR for the repository being rebased and an +// empty GIT_PREFIX. Git treats both as stronger than -C. +func gitEnvWithoutRepository(env []string) []string { + filtered := make([]string, 0, len(env)) + for _, entry := range env { + key, _, _ := strings.Cut(entry, "=") + if gitRepositoryEnv(key) { + continue + } + filtered = append(filtered, entry) + } + return filtered +} + +func gitRepositoryEnv(key string) bool { + switch key { + case "GIT_DIR", "GIT_WORK_TREE", "GIT_COMMON_DIR", "GIT_OBJECT_DIRECTORY", "GIT_INDEX_FILE", "GIT_NAMESPACE", "GIT_PREFIX": + return true + default: + return false + } +} + func outputFixFile(name string, f *fixFile, cwd string, printDiff bool) error { if bytes.Equal(f.original, f.result) { return nil diff --git a/internal/driver/fix_test.go b/internal/driver/fix_test.go index 2db921f..67a657f 100644 --- a/internal/driver/fix_test.go +++ b/internal/driver/fix_test.go @@ -5,7 +5,6 @@ import ( "go/ast" "io" "os" - "os/exec" "path/filepath" "testing" @@ -85,9 +84,7 @@ func TestFixes(t *testing.T) { } git := func(args ...string) { t.Helper() - cmd := exec.CommandContext(t.Context(), "git", append([]string{"-C", dir}, args...)...) - out, err := cmd.CombinedOutput() - require.NoError(t, err, "%s", out) + runGit(t, dir, args...) } git("init", "-q") git("add", ".") diff --git a/internal/driver/git_command_test.go b/internal/driver/git_command_test.go new file mode 100644 index 0000000..8826141 --- /dev/null +++ b/internal/driver/git_command_test.go @@ -0,0 +1,48 @@ +package driver_test + +import ( + "os" + "os/exec" + "strings" + "testing" + + "github.com/stretchr/testify/require" +) + +func runGit(t *testing.T, dir string, args ...string) string { + t.Helper() + return runGitInput(t, dir, "", args...) +} + +func runGitInput(t *testing.T, dir, input string, args ...string) string { + t.Helper() + cmd := exec.CommandContext(t.Context(), "git", append([]string{"-C", dir}, args...)...) + cmd.Env = gitEnvWithoutRepository(os.Environ()) + cmd.Stdin = strings.NewReader(input) + out, err := cmd.CombinedOutput() + require.NoError(t, err, "%s", out) + return string(out) +} + +// gitEnvWithoutRepository matches gitRepositoryEnv in fix.go. git rebase --exec +// exports GIT_DIR and an empty GIT_PREFIX, and Git treats both as stronger than -C. +func gitEnvWithoutRepository(env []string) []string { + filtered := make([]string, 0, len(env)) + for _, entry := range env { + key, _, _ := strings.Cut(entry, "=") + if gitRepositoryEnv(key) { + continue + } + filtered = append(filtered, entry) + } + return filtered +} + +func gitRepositoryEnv(key string) bool { + switch key { + case "GIT_DIR", "GIT_WORK_TREE", "GIT_COMMON_DIR", "GIT_OBJECT_DIRECTORY", "GIT_INDEX_FILE", "GIT_NAMESPACE", "GIT_PREFIX": + return true + default: + return false + } +} diff --git a/internal/driver/git_safety_test.go b/internal/driver/git_safety_test.go index 0e3f263..860800c 100644 --- a/internal/driver/git_safety_test.go +++ b/internal/driver/git_safety_test.go @@ -2,7 +2,6 @@ package driver_test import ( "os" - "os/exec" "path/filepath" "testing" @@ -30,9 +29,7 @@ func TestFixGitSafety(t *testing.T) { dir := t.TempDir() git := func(args ...string) { t.Helper() - cmd := exec.Command("git", append([]string{"-C", dir}, args...)...) - out, err := cmd.CombinedOutput() - require.NoError(t, err, "%s", out) + runGit(t, dir, args...) } write := func(name, value string) { t.Helper() diff --git a/internal/driver/iterate_test.go b/internal/driver/iterate_test.go index 0dd8cce..0218d28 100644 --- a/internal/driver/iterate_test.go +++ b/internal/driver/iterate_test.go @@ -5,7 +5,6 @@ import ( "go/ast" "go/format" "os" - "os/exec" "path/filepath" "strconv" "strings" @@ -30,9 +29,9 @@ func fixRepoFiles(t *testing.T, files map[string]string) string { for name, source := range files { require.NoError(t, os.WriteFile(filepath.Join(dir, name), []byte(source), 0o644)) } - gitCommand(t, dir, "", "init", "-q") - gitCommand(t, dir, "", "add", ".") - gitCommand(t, dir, "", "-c", "user.name=Test", "-c", "user.email=test@example.com", "commit", "-qm", "initial") + runGitInput(t, dir, "", "init", "-q") + runGitInput(t, dir, "", "add", ".") + runGitInput(t, dir, "", "-c", "user.name=Test", "-c", "user.email=test@example.com", "commit", "-qm", "initial") cwd, err := os.Getwd() require.NoError(t, err) require.NoError(t, os.Chdir(dir)) @@ -42,10 +41,7 @@ func fixRepoFiles(t *testing.T, files map[string]string) string { func gitCommand(t *testing.T, dir, input string, args ...string) { t.Helper() - cmd := exec.CommandContext(t.Context(), "git", append([]string{"-C", dir}, args...)...) - cmd.Stdin = strings.NewReader(input) - out, err := cmd.CombinedOutput() - require.NoError(t, err, "%s", out) + runGitInput(t, dir, input, args...) } func runFix(t *testing.T, analyzer *analysis.Analyzer, diff bool) (int, string, string) { From 9249189e688152b81cd30fd1e943bf1e1c6d0f14 Mon Sep 17 00:00:00 2001 From: Nathan Nutter Date: Tue, 17 Nov 2026 11:40:38 -0600 Subject: [PATCH 2/6] Add driver benchmarks for analysis time and allocations Measure package loading together with syntax-only analysis, fact-based NilAway analysis, and a no-op fix pass before optimizing the driver. Go benchmark CPU and memory profiles can separate prerequisite work from package loading without adding profiling flags to the CLI. Change-Id: I0e2f02dc6f58ec8dbf0ddaad1302a02f2a9830d0 --- internal/driver/benchmark_test.go | 42 +++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 internal/driver/benchmark_test.go diff --git a/internal/driver/benchmark_test.go b/internal/driver/benchmark_test.go new file mode 100644 index 0000000..ab9ddb0 --- /dev/null +++ b/internal/driver/benchmark_test.go @@ -0,0 +1,42 @@ +package driver_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "golang.org/x/tools/go/analysis" + + "github.com/nnutter/constable/internal/analysis/nilaway" + "github.com/nnutter/constable/internal/analysis/nonmutating" + "github.com/nnutter/constable/internal/driver" +) + +// BenchmarkRun includes package loading on every iteration, as separate CLI +// invocations do. The directive package provides a small real workload with +// standard-library and test dependencies. Go's build cache remains warm. +func BenchmarkRun(b *testing.B) { + b.Chdir("../..") + cases := []struct { + name string + analyzers []*analysis.Analyzer + fix bool + }{ + {name: "syntax", analyzers: []*analysis.Analyzer{nonmutating.Analyzer}}, + {name: "facts", analyzers: []*analysis.Analyzer{nilaway.Analyzer}}, + {name: "facts_fix_noop", analyzers: []*analysis.Analyzer{nilaway.Analyzer}, fix: true}, + } + for _, tc := range cases { + b.Run(tc.name, func(b *testing.B) { + opts := driver.Options{ + Context: -1, + IncludeTests: true, + Fix: tc.fix, + AfterLoad: nilaway.UseMainModules, + } + b.ReportAllocs() + for b.Loop() { + require.Equal(b, 0, driver.Run([]string{"./internal/directive"}, tc.analyzers, opts)) + } + }) + } +} From dcb0447d4d863b6ccb7ae46e519e85fead44b1c4 Mon Sep 17 00:00:00 2001 From: Nathan Nutter Date: Tue, 17 Nov 2026 11:42:07 -0600 Subject: [PATCH 3/6] Avoid retaining parsed source during ordinary checks Only fix passes consume the source snapshots captured by package loading. Ordinary checks discarded them after cloning every parsed file, including dependency files needed by fact-based analyzers. Keep the parser settings and fix snapshots unchanged, but skip the snapshot allocations and locking when fixes are not requested. Change-Id: I78ee9339c1d4495a78e94984b0e3de8c83465838 --- internal/driver/driver.go | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/internal/driver/driver.go b/internal/driver/driver.go index 7c7bd3f..3c60184 100644 --- a/internal/driver/driver.go +++ b/internal/driver/driver.go @@ -487,7 +487,7 @@ func Run(args []string, analyzers []*analysis.Analyzer, opts Options) (exitcode return runFixes(args, analyzers, opts, cwd) } - initial, _, err := load(args, opts.IncludeTests, needFacts(analyzers), nil) + initial, _, err := load(args, opts, needFacts(analyzers), nil) if err != nil { log.Print(err) exitAtLeast(1) @@ -610,7 +610,7 @@ func fixPassLimit(sources map[*token.File][]byte) int { } func analyzeFixPass(args []string, analyzers []*analysis.Analyzer, opts Options, overlay map[string][]byte) (*checker.Graph, map[*token.File][]byte, error) { - initial, sources, err := load(args, opts.IncludeTests, needFacts(analyzers), overlay) + initial, sources, err := load(args, opts, needFacts(analyzers), overlay) if err != nil { return nil, nil, err } @@ -744,24 +744,30 @@ func needFacts(analyzers []*analysis.Analyzer) bool { return false } -func load(patterns []string, includeTests, allSyntax bool, overlay map[string][]byte) ([]*packages.Package, map[*token.File][]byte, error) { +func load(patterns []string, opts Options, allSyntax bool, overlay map[string][]byte) ([]*packages.Package, map[*token.File][]byte, error) { mode := packages.LoadSyntax if allSyntax { mode = packages.LoadAllSyntax } mode |= packages.NeedModule - sources := make(map[*token.File][]byte) + // Only fix passes need a snapshot to validate edits against parsed source. + var sources map[*token.File][]byte + if opts.Fix { + sources = make(map[*token.File][]byte) + } var mu sync.Mutex conf := packages.Config{ Mode: mode, - Tests: includeTests, + Tests: opts.IncludeTests, Overlay: overlay, ParseFile: func(fset *token.FileSet, filename string, src []byte) (*ast.File, error) { file, err := parser.ParseFile(fset, filename, src, parser.AllErrors|parser.ParseComments) - if file != nil { - mu.Lock() - sources[fset.File(file.Pos())] = bytes.Clone(src) - mu.Unlock() + if opts.Fix { + if file != nil { + mu.Lock() + sources[fset.File(file.Pos())] = bytes.Clone(src) + mu.Unlock() + } } return file, err }, From 0d32726e2752e650f9455bc09b402a3dabaab412 Mon Sep 17 00:00:00 2001 From: Nathan Nutter Date: Tue, 17 Nov 2026 11:49:43 -0600 Subject: [PATCH 4/6] Skip NilAway SSA construction outside its configured scope NilAway checks package scope after the driver has run its prerequisites. Its function-contract prerequisite therefore built SSA for dependencies that NilAway would not analyze. Apply the same scope check before building SSA. Preserve the upstream requirement graph and shared prerequisite identities, and leave upstream analyzers untouched. Explicit include and exclude settings still decide which packages receive analysis. Compare diagnostics against unmodified upstream analysis across package scopes, including cross-package nil flows and inferred contracts. Existing functional tests and expected fixes remain unchanged. Change-Id: Ie6857a8045c265381f986f1de35413b3ca9b2f54 --- internal/analysis/nilaway/nilaway.go | 2 +- internal/analysis/nilaway/ssa.go | 73 +++++++++++++++++ internal/analysis/nilaway/ssa_test.go | 82 +++++++++++++++++++ .../testdata/src/scope/client/client.go | 25 ++++++ .../nilaway/testdata/src/scope/lib/lib.go | 14 ++++ 5 files changed, 195 insertions(+), 1 deletion(-) create mode 100644 internal/analysis/nilaway/ssa.go create mode 100644 internal/analysis/nilaway/ssa_test.go create mode 100644 internal/analysis/nilaway/testdata/src/scope/client/client.go create mode 100644 internal/analysis/nilaway/testdata/src/scope/lib/lib.go diff --git a/internal/analysis/nilaway/nilaway.go b/internal/analysis/nilaway/nilaway.go index 04422b1..e07703d 100644 --- a/internal/analysis/nilaway/nilaway.go +++ b/internal/analysis/nilaway/nilaway.go @@ -20,7 +20,7 @@ import ( // Analyzer reports a nil value that flows to a dereference. It is the upstream // analyzer with constable's generated-file policy applied and with the // analyzed packages limited to the module that constable runs on. -var Analyzer = generated.Skip(nilaway.Analyzer) +var Analyzer = generated.Skip(scopeSSA(nilaway.Analyzer)) // includeAllPkgs keeps nilaway's own default, every package that it loads. var includeAllPkgs bool diff --git a/internal/analysis/nilaway/ssa.go b/internal/analysis/nilaway/ssa.go new file mode 100644 index 0000000..33394d9 --- /dev/null +++ b/internal/analysis/nilaway/ssa.go @@ -0,0 +1,73 @@ +package nilaway + +import ( + "slices" + + "go.uber.org/nilaway/config" + "golang.org/x/tools/go/analysis" + "golang.org/x/tools/go/analysis/passes/buildssa" +) + +// scopeSSA copies NilAway's requirement graph so that its SSA prerequisite +// observes the same scope as the function-contract analyzer that consumes it. +// The checker runs prerequisites before their consumers, so the consumer's +// own scope check cannot prevent building SSA for excluded dependencies. +// Copy only the changed prerequisite and its consumers. Other prerequisites +// retain their identities because analyzers outside NilAway may share their +// fact types. Upstream analyzers remain unchanged for other users. +func scopeSSA(root *analysis.Analyzer) *analysis.Analyzer { + copies := make(map[*analysis.Analyzer]*analysis.Analyzer) + var clone func(*analysis.Analyzer) *analysis.Analyzer + clone = func(a *analysis.Analyzer) *analysis.Analyzer { + if copy := copies[a]; copy != nil { + return copy + } + copy := *a + copies[a] = © + requires, run := a.Requires, a.Run + changed := a == buildssa.Analyzer + if changed { + requires = append(slices.Clone(requires), config.Analyzer) + run = runScopedSSA + } + copy.Requires = make([]*analysis.Analyzer, len(requires)) + for i, req := range requires { + copy.Requires[i] = clone(req) + if copy.Requires[i] != req { + changed = true + } + } + if !changed { + copies[a] = a + return a + } + copy.Run = originalPass(a, requires, copies, run) + return © + } + return clone(root) +} + +// originalPass restores the analyzer identities that upstream Run functions +// use to look up prerequisite results. Copy the pass rather than changing the +// checker's pass, including when another adapter has installed an overlay. +func originalPass(a *analysis.Analyzer, requires []*analysis.Analyzer, copies map[*analysis.Analyzer]*analysis.Analyzer, run func(*analysis.Pass) (any, error)) func(*analysis.Pass) (any, error) { + return func(pass *analysis.Pass) (any, error) { + original := *pass + original.Analyzer = a + original.ResultOf = make(map[*analysis.Analyzer]any, len(requires)) + for _, req := range requires { + original.ResultOf[req] = pass.ResultOf[copies[req]] + } + return run(&original) + } +} + +func runScopedSSA(pass *analysis.Pass) (any, error) { + conf := pass.ResultOf[config.Analyzer].(*config.Config) + if !conf.IsPkgInScope(pass.Pkg) { + // The function-contract analyzer returns before reading SSA for these + // packages. Return the declared result type without constructing SSA. + return new(buildssa.SSA), nil + } + return buildssa.Analyzer.Run(pass) +} diff --git a/internal/analysis/nilaway/ssa_test.go b/internal/analysis/nilaway/ssa_test.go new file mode 100644 index 0000000..31df131 --- /dev/null +++ b/internal/analysis/nilaway/ssa_test.go @@ -0,0 +1,82 @@ +package nilaway_test + +import ( + "fmt" + "os" + "slices" + "testing" + + "github.com/stretchr/testify/require" + upstream "go.uber.org/nilaway" + "go.uber.org/nilaway/config" + "golang.org/x/tools/go/analysis" + "golang.org/x/tools/go/analysis/analysistest" + "golang.org/x/tools/go/analysis/checker" + "golang.org/x/tools/go/packages" + + "github.com/nnutter/constable/internal/analysis/nilaway" + "github.com/nnutter/constable/internal/generated" +) + +// Compare at the analyzer boundary against unmodified upstream analysis with +// the same generated-file policy. Inferred contracts and facts cross package +// boundaries in the fixture, so dropping useful SSA can change diagnostics. +func TestScopedSSAMatchesUpstream(t *testing.T) { + pkgs, err := packages.Load(&packages.Config{ + Mode: packages.LoadAllSyntax, + Dir: analysistest.TestData(), + Env: append(os.Environ(), "GO111MODULE=off", "GOPATH="+analysistest.TestData()), + }, "scope/...") + require.NoError(t, err) + require.NotEmpty(t, pkgs) + require.Zero(t, packages.PrintErrors(pkgs)) + + cases := []struct { + name string + include string + exclude string + }{ + {name: "all"}, + {name: "module", include: "scope"}, + {name: "client_only", include: "scope/client"}, + {name: "library_only", include: "scope/lib"}, + {name: "exclude_library", include: "scope", exclude: "scope/lib"}, + {name: "excluded", include: "another/module"}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + setIncludePkgs(t, tc.include) + exclude := config.Analyzer.Flags.Lookup(config.ExcludePkgsFlag) + require.NotNil(t, exclude) + previous := exclude.Value.String() + require.NoError(t, exclude.Value.Set(tc.exclude)) + t.Cleanup(func() { require.NoError(t, exclude.Value.Set(previous)) }) + want := analyzerDiagnostics(t, generated.Skip(upstream.Analyzer), pkgs) + got := analyzerDiagnostics(t, nilaway.Analyzer, pkgs) + require.Equal(t, want, got) + if tc.name == "module" { + require.NotEmpty(t, got, "the fixture must exercise reported nil flows") + } + if tc.name == "excluded" { + require.Empty(t, got) + } + }) + } +} + +func analyzerDiagnostics(t *testing.T, a *analysis.Analyzer, pkgs []*packages.Package) []string { + t.Helper() + graph, err := checker.Analyze([]*analysis.Analyzer{a}, pkgs, nil) + require.NoError(t, err) + var diagnostics []string + for act := range graph.All() { + require.NoError(t, act.Err) + if act.IsRoot { + for _, d := range act.Diagnostics { + diagnostics = append(diagnostics, fmt.Sprintf("%s: %s", act.Package.Fset.Position(d.Pos), d.Message)) + } + } + } + slices.Sort(diagnostics) + return diagnostics +} diff --git a/internal/analysis/nilaway/testdata/src/scope/client/client.go b/internal/analysis/nilaway/testdata/src/scope/client/client.go new file mode 100644 index 0000000..6937518 --- /dev/null +++ b/internal/analysis/nilaway/testdata/src/scope/client/client.go @@ -0,0 +1,25 @@ +package client + +import ( + "strings" + + "scope/lib" +) + +func Safe() int { + value := 1 + return *lib.Identity(&value) +} + +func Unsafe() int { + return *lib.Missing() +} + +func Local() int { + var p *int + return *p +} + +func StandardLibrary() string { + return strings.TrimSpace(" safe ") +} diff --git a/internal/analysis/nilaway/testdata/src/scope/lib/lib.go b/internal/analysis/nilaway/testdata/src/scope/lib/lib.go new file mode 100644 index 0000000..a49a037 --- /dev/null +++ b/internal/analysis/nilaway/testdata/src/scope/lib/lib.go @@ -0,0 +1,14 @@ +package lib + +// Identity's nonnil-to-nonnil contract is inferred from SSA. +func Identity(p *int) *int { + return p +} + +func Missing() *int { + return nil +} + +func Dereference() int { + return *Missing() +} From 0f19d72057e8fd5d68f8fd213f1824c0f467310c Mon Sep 17 00:00:00 2001 From: Nathan Nutter Date: Tue, 17 Nov 2026 11:50:49 -0600 Subject: [PATCH 5/6] Refactor: Extract NilAway prerequisite replacement Extract the graph-copying operation from SSA scoping so the next optimization can filter suppression-comment inputs without mutating upstream analyzers or duplicating prerequisite result remapping. Change-Id: Iacfc1320dc40e3d8c0cac09bb8a43b2592d61df4 --- internal/analysis/nilaway/ssa.go | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/internal/analysis/nilaway/ssa.go b/internal/analysis/nilaway/ssa.go index 33394d9..09ee2bb 100644 --- a/internal/analysis/nilaway/ssa.go +++ b/internal/analysis/nilaway/ssa.go @@ -16,6 +16,15 @@ import ( // retain their identities because analyzers outside NilAway may share their // fact types. Upstream analyzers remain unchanged for other users. func scopeSSA(root *analysis.Analyzer) *analysis.Analyzer { + scoped := *buildssa.Analyzer + scoped.Requires = append(slices.Clone(scoped.Requires), config.Analyzer) + scoped.Run = runScopedSSA + return replacePrerequisite(root, buildssa.Analyzer, &scoped) +} + +// replacePrerequisite copies only the consumers of a changed prerequisite, +// preserving shared identities and the keys upstream uses in ResultOf. +func replacePrerequisite(root, target, replacement *analysis.Analyzer) *analysis.Analyzer { copies := make(map[*analysis.Analyzer]*analysis.Analyzer) var clone func(*analysis.Analyzer) *analysis.Analyzer clone = func(a *analysis.Analyzer) *analysis.Analyzer { @@ -25,10 +34,9 @@ func scopeSSA(root *analysis.Analyzer) *analysis.Analyzer { copy := *a copies[a] = © requires, run := a.Requires, a.Run - changed := a == buildssa.Analyzer + changed := a == target if changed { - requires = append(slices.Clone(requires), config.Analyzer) - run = runScopedSSA + requires, run = replacement.Requires, replacement.Run } copy.Requires = make([]*analysis.Analyzer, len(requires)) for i, req := range requires { From e31bab8d88807871176f3c14c941b3b072238350 Mon Sep 17 00:00:00 2001 From: Nathan Nutter Date: Tue, 17 Nov 2026 11:58:36 -0600 Subject: [PATCH 6/6] Skip NilAway comment maps for files without suppression text Profiling after SSA scoping showed that suppression-comment parsing still built comment maps for every dependency file. Pass only files containing nolint text to the upstream suppression parser. Keep its directive recognition, range construction, and fact imports and exports unchanged. Excluded packages still run because their suppression facts can affect downstream reports. Compare diagnostics with upstream analysis using local suppressions, cross-package flows, and an unsuppressed nil flow. No existing test expectations change. Change-Id: Ib2eaaa669acaee197dfb95e0275dc0517e39330a --- internal/analysis/nilaway/nilaway.go | 2 +- internal/analysis/nilaway/nolint.go | 41 +++++++++++++++++++ internal/analysis/nilaway/nolint_test.go | 31 ++++++++++++++ .../testdata/src/suppression/client/client.go | 16 ++++++++ .../testdata/src/suppression/client/plain.go | 9 ++++ .../testdata/src/suppression/lib/lib.go | 25 +++++++++++ 6 files changed, 123 insertions(+), 1 deletion(-) create mode 100644 internal/analysis/nilaway/nolint.go create mode 100644 internal/analysis/nilaway/nolint_test.go create mode 100644 internal/analysis/nilaway/testdata/src/suppression/client/client.go create mode 100644 internal/analysis/nilaway/testdata/src/suppression/client/plain.go create mode 100644 internal/analysis/nilaway/testdata/src/suppression/lib/lib.go diff --git a/internal/analysis/nilaway/nilaway.go b/internal/analysis/nilaway/nilaway.go index e07703d..34c5dbe 100644 --- a/internal/analysis/nilaway/nilaway.go +++ b/internal/analysis/nilaway/nilaway.go @@ -20,7 +20,7 @@ import ( // Analyzer reports a nil value that flows to a dereference. It is the upstream // analyzer with constable's generated-file policy applied and with the // analyzed packages limited to the module that constable runs on. -var Analyzer = generated.Skip(scopeSSA(nilaway.Analyzer)) +var Analyzer = generated.Skip(skipEmptyNoLintFiles(scopeSSA(nilaway.Analyzer))) // includeAllPkgs keeps nilaway's own default, every package that it loads. var includeAllPkgs bool diff --git a/internal/analysis/nilaway/nolint.go b/internal/analysis/nilaway/nolint.go new file mode 100644 index 0000000..42591eb --- /dev/null +++ b/internal/analysis/nilaway/nolint.go @@ -0,0 +1,41 @@ +package nilaway + +import ( + "go/ast" + "strings" + + "go.uber.org/nilaway/diagnostic" + "golang.org/x/tools/go/analysis" +) + +// skipEmptyNoLintFiles avoids constructing comment maps for files without +// suppression comments. Still run the upstream analyzer for every package: +// it imports and exports suppression facts used by downstream diagnostics, +// even for packages outside NilAway's configured analysis scope. +func skipEmptyNoLintFiles(root *analysis.Analyzer) *analysis.Analyzer { + filtered := *diagnostic.NoLintAnalyzer + filtered.Run = func(pass *analysis.Pass) (any, error) { + copy := *pass + copy.Files = nil + for _, file := range pass.Files { + if mayHaveNoLint(file) { + copy.Files = append(copy.Files, file) + } + } + return diagnostic.NoLintAnalyzer.Run(©) + } + return replacePrerequisite(root, diagnostic.NoLintAnalyzer, &filtered) +} + +func mayHaveNoLint(file *ast.File) bool { + for _, group := range file.Comments { + for _, comment := range group.List { + // Deliberately accept more than the upstream parser. It remains + // responsible for recognizing valid directives and their ranges. + if strings.Contains(comment.Text, "nolint") { + return true + } + } + } + return false +} diff --git a/internal/analysis/nilaway/nolint_test.go b/internal/analysis/nilaway/nolint_test.go new file mode 100644 index 0000000..a49855a --- /dev/null +++ b/internal/analysis/nilaway/nolint_test.go @@ -0,0 +1,31 @@ +package nilaway_test + +import ( + "os" + "testing" + + "github.com/stretchr/testify/require" + upstream "go.uber.org/nilaway" + "golang.org/x/tools/go/analysis/analysistest" + "golang.org/x/tools/go/packages" + + "github.com/nnutter/constable/internal/analysis/nilaway" + "github.com/nnutter/constable/internal/generated" +) + +func TestSuppressionFactsMatchUpstream(t *testing.T) { + setIncludePkgs(t, "suppression") + pkgs, err := packages.Load(&packages.Config{ + Mode: packages.LoadAllSyntax, + Dir: analysistest.TestData(), + Env: append(os.Environ(), "GO111MODULE=off", "GOPATH="+analysistest.TestData()), + }, "suppression/...") + require.NoError(t, err) + require.NotEmpty(t, pkgs) + require.Zero(t, packages.PrintErrors(pkgs)) + + want := analyzerDiagnostics(t, generated.Skip(upstream.Analyzer), pkgs) + require.NotEmpty(t, want, "the unsuppressed nil flow must still be reported") + got := analyzerDiagnostics(t, nilaway.Analyzer, pkgs) + require.Equal(t, want, got) +} diff --git a/internal/analysis/nilaway/testdata/src/suppression/client/client.go b/internal/analysis/nilaway/testdata/src/suppression/client/client.go new file mode 100644 index 0000000..26f0f6c --- /dev/null +++ b/internal/analysis/nilaway/testdata/src/suppression/client/client.go @@ -0,0 +1,16 @@ +package client + +import "suppression/lib" + +func CrossPackage() int { + return *lib.Missing() +} + +func SuppressedUpstream() int { + return lib.Dereference(nil) +} + +func Unsuppressed() int { + var p *int + return *p +} diff --git a/internal/analysis/nilaway/testdata/src/suppression/client/plain.go b/internal/analysis/nilaway/testdata/src/suppression/client/plain.go new file mode 100644 index 0000000..e05f5bc --- /dev/null +++ b/internal/analysis/nilaway/testdata/src/suppression/client/plain.go @@ -0,0 +1,9 @@ +package client + +// This file has comments but no suppression directive. +func Safe(p *int) int { + if p == nil { + return 0 + } + return *p +} diff --git a/internal/analysis/nilaway/testdata/src/suppression/lib/lib.go b/internal/analysis/nilaway/testdata/src/suppression/lib/lib.go new file mode 100644 index 0000000..119e8ed --- /dev/null +++ b/internal/analysis/nilaway/testdata/src/suppression/lib/lib.go @@ -0,0 +1,25 @@ +package lib + +func Missing() *int { + return nil //nolint:nilaway +} + +func Dereference(p *int) int { + return *p //nolint:nilaway +} + +func Inline() int { + var p *int + return *p //nolint:nilaway +} + +func Block() int { + var p *int + return *p /*nolint:nilaway*/ +} + +//nolint:all +func Declaration() int { + var p *int + return *p +}