diff --git a/internal/analysis/nilaway/nilaway.go b/internal/analysis/nilaway/nilaway.go index 04422b1..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(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/ssa.go b/internal/analysis/nilaway/ssa.go new file mode 100644 index 0000000..09ee2bb --- /dev/null +++ b/internal/analysis/nilaway/ssa.go @@ -0,0 +1,81 @@ +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 { + 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 { + if copy := copies[a]; copy != nil { + return copy + } + copy := *a + copies[a] = © + requires, run := a.Requires, a.Run + changed := a == target + if changed { + requires, run = replacement.Requires, replacement.Run + } + 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() +} 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 +} 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/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)) + } + }) + } +} 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 }, 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) {