## What is wrong For a `*testing.T` parameter, `thelper` checks three things on every func literal and on every function declaration whose name does not begin with `Test`: the parameter is named `t`, the body opens with `t.Helper()`, and the parameter comes first or directly after a `context.Context`. It reports nothing for the function passed to `t.Run`, `b.Run`, `f.Fuzz` or `synctest.Test`, keyed on that function's own position. The analyzer records each such position in a filter and drops those reports before it emits them. The code is `Filter` in `pkg/analyzer/analyzer.go` and `Flush` in `pkg/analyzer/report.go` of `github.com/kulti/thelper` v0.7.1, the version golangci-lint 2.12.2 pins. Many `//nolint:thelper` tokens were written for a shape `thelper` never reports. Those tokens suppress nothing. `nolintlint` is disabled in `.golangci.yaml`, so no pipeline says so. Nothing fails when a token is wrong in either direction, which is why the count has to be measured rather than reasoned about. ## Measurement Measured at `75b8c6ad8`, over `git ls-files '*.go'`. | Group | Files | Tokens | |---|---|---| | Carries a `thelper` token | 65 | 216 | | Carries a token, and `thelper` is silent | 44 | 161 | | Of those, in a file with **no** `integration` tag | 26 | 116 | | Of those, in an `integration`-tagged file | 18 | 45 | The 116 in untagged files are the actionable half, because CI compiles those files today. `.golangci.yaml` sets `linters.default: all` with `thelper` absent from `disable` and `run.tests: true`, so `thelper` runs over them on every pipeline. | Package | Dead tokens | Files | |---|---|---| | `internal/managementapi` | 75 | 9 | | `internal/format` | 20 | 6 | | `internal/datastore` | 12 | 6 | | `cmd/artifact-registry` | 9 | 5 | The 45 in tagged files reach no pipeline while `.golangci.yaml` sets no `run.build-tags`. They are still wrong, and `docs/dev/go-testing.md` is explicit that a directive in a tagged file documents intent and is not evidence that a linter agreed. Four files draw findings and carry no token, 8 findings between them. All four are `integration`-tagged, so none of them reaches a pipeline either. - `internal/datastore/npm_read_integration_test.go` (1) - `internal/datastore/npm_remote_update_integration_test.go` (3) - `internal/datastore/repositories_list_integration_test.go` (1) - `internal/format/npm/rebuild_counter_helpers_integration_test.go` (3) ### How to re-run it Standalone `thelper` carries no `//nolint` layer, so it shows every finding: ```shell go install github.com/kulti/thelper/cmd/thelper@v0.7.1 GOFLAGS=-tags=integration thelper ./... ``` The `-tags` flag of `thelper` does not reach `go/packages`. Only `GOFLAGS` sets the build tags, and a run without it never loads the tagged files, which inflates the silent set to 57 files and 187 tokens. Cross-check with golangci-lint, which honors the directives: ```shell golangci-lint run --build-tags=integration --default=none --enable=thelper \ --max-same-issues=0 --max-issues-per-linter=0 --uniq-by-line=false ./... ``` `--uniq-by-line=false` is required rather than optional. The dedupe counter is `map[filePath]map[int]int` with no linter key and it runs after the nolint filter, so a `thelper` finding on a line another linter also flags is dropped, and the site then reads as one whose token suppresses nothing. Re-derive the counts at the commit you work from. The tree-wide figure was 71 findings across 14 files in `internal/datastore` alone at `56ff2e147`, so the numbers move fast. ## The work 1. Remove the `thelper` token from the 44 files where `thelper` is silent. Keep the other tokens in each directive, and trim the trailing comment to the tokens that survive. Where `thelper` is the directive's only token, the whole directive goes. 1. Decide the 4 files that carry findings and no token. Either rename the parameter to `t`, or add an earned `thelper` token with its reason. The 116 untagged tokens across four packages can be taken independently of the 45 tagged ones, and they are the half a pipeline can regress. ## Why this is deferred, and what ends the deferral The trim touches 48 files. While a branch holds edits to one of those files, a commit here produces a rebase conflict on that branch. The overlap is not uniform: about 29% of the `internal/datastore` files sit under an open branch, against about 9% of the files in the other three packages, so the packages outside `internal/datastore` can be swept sooner. No pipeline reports any of this while `nolintlint` stays disabled. The 8 findings in the 4 unannotated files reach no pipeline while `.golangci.yaml` sets no `run.build-tags`. When a lint job starts to set the `integration` tag, those findings become gating, and that half of this issue turns from cleanup into a blocker. The guardrail that produced the wrong tokens is corrected in https://gitlab.com/gitlab-org/ops/artifact-registry/-/merge_requests/1701. While that merge request is open, `CLAUDE.md` still describes `thelper` as reporting one exempt shape and still explains `uniq-by-line` as keeping one issue per line per linter, and an author who follows it adds another inert token. Once it merges, the guardrail names all four filtered shapes, names all three checks, points at this issue for the sweep, and puts `--uniq-by-line=false` in the command it prescribes. ## Label choice The type label is `type::maintenance`. The work edits test files and changes no behavior, so it is neither a feature nor a defect in shipped code. The subtype choice was between `maintenance::refactor` and `maintenance::workflow`. `refactor` fits, because the change edits code and preserves behavior. `workflow` covers a change to the development process, and the guardrail correction merge request carries that label instead.