[sergo] Sergo Report: tolowerequalfold Self-Compare Precision Audit (21st Linter) — 2026-06-04

[github-actions[bot]]

Executive Summary

R27 (2026-06-04) combined a reverify of the previous run's finding with discovery of a newly-registered linter. The reverify confirmed a prediction: sg26a1 (seenmapbool) did NOT land — cgo.yml:1040 still carries 11 enforced flags (no -seenmapbool) and the linter's inspectBody still has no escape filter. This breaks the 5-consecutive-run enforce-landing streak (R22→R26), validating the hypothesis that the first non-near-zero registered linter (60+ sites) would not follow the fast fix-to-zero-then-enforce pattern.

The new-exploration half found the 21st registered linter, tolowerequalfold (registry grew 20→21), which recommends strings.EqualFold for strings.ToLower/ToUpper(x) == y comparisons. It ships with a correctness-affecting precision gap: it false-positives the strings.ToLower(x) == x case-detection idiom — and at one site, mechanically applying the linter's suggestion would silently invert a validation guard. Filed as sg27a1.

Success score: 9/10.

🛠️ Serena Tools Update

Tools Snapshot

• Serena LSP tools: 23 (stable since R4 — 24 consecutive runs, no change)
• New tools: None
• Removed tools: None
• Custom linter registry: 20 → 21 (tolowerequalfold added at cmd/linters/main.go:38,63)

Tools Used Today

• Grep / Read / Glob — primary static analysis (Serena find_symbol remains 70s+ on broad queries; Grep preferred per cached gotchas)
• serena --help — tool-count verification

📊 Strategy Selection

Cached Reuse Component (50%) — reverify sg26a1

• Adapted from: R26 reverify-plus-new-seenmapbool-20th-linter-escape-precision-audit (score 9/10)
• Result: sg26a1 unlanded. cgo.yml:1040 = 11 flags (no -seenmapbool); seenmapbool.go:64-170 inspectBody still collects candidates and checks only same-body non-true writes — no return/arg/field/closure escape detection. Streak stalled. sg26a1 (filed 06-02, +7d expiry) remains open → not re-filed.

New Exploration Component (50%) — 21st-linter precision audit

• Approach: enumerate the new linter's exact AST trigger, then partition production matches into true-positives vs. false-positives by intent.
• Hypothesis: a freshly-registered linter likely carries an uncovered FP idiom (precision sub-pattern seen in sg24a1, sg26a1).
• Confirmed: tolowerequalfold reports when lowerLeft || lowerRight regardless of the opposite operand, so the self-comparison idiom is flagged.

Combined Rationale

Reverify guards against regression and tracks the enforce pipeline's health; the new-linter precision audit supplies an independently-landable single-file fix even when the enforce pipeline stalls on hard (non-near-zero) linters.

🔍 Analysis Execution

Codebase Context

• Custom linters registered: 21 (11 enforced, 10 unenforced)
• CI enforcement: cgo.yml:1040 make golint-custom LINTER_FLAGS="..." — 11 positive flags
• Focus: pkg/linters/tolowerequalfold/, pkg/linters/seenmapbool/, and strings.ToLower/ToUpper comparison sites across pkg/ + cmd/

Findings Summary

• Total: 6 | Critical: 0 | High: 1 (sg27a1) | Medium: 1 (sg26a1 stalled, tracked) | Low/Informational: 4

📋 Detailed Findings

High — sg27a1: tolowerequalfold false-positives the self-comparison idiom

The linter flags ==/!= where either operand is strings.ToLower/ToUpper(...), ignoring whether the other operand is the same expression. This false-positives the case-detection idiom strings.ToLower(x) != x ("does x contain uppercase?"), which cannot become EqualFold — EqualFold(x, x) is always true.

File:Line	Code	Hazard if "fixed"
pkg/workflow/tools_validation_github.go:191	strings.ToLower(pattern) != pattern	inverts a "must be lowercase" guard → non-lowercase patterns pass
pkg/cli/logs_report_tools.go:56	strings.ToLower(name) != name	breaks hasCapital detection
pkg/cli/codemod_discussion_trigger_categories.go:68	typeString != strings.ToLower(typeString)	breaks lowercase check

Testdata okExamples (testdata/src/tolowerequalfold/tolowerequalfold.go:17-26) does not cover self-comparison → genuinely unhandled. Fix: add a caseConvArg + sameOperand (via pass.TypesInfo.ObjectOf) filter that skips when the opposite operand equals the lowered inner argument. Single-file linter change + testdata.

Medium — sg26a1 (tracked, stalled): seenmapbool escape-blindness + unenforced

Unchanged since R26. inspectBody is blind to maps that escape their declaring function (returned/passed/stored/captured), so ≥12 flagged map[string]bool set decls (e.g. toImportSet, managedPatternsWithInlineComment, buildForbiddenFieldsMap) would require non-local signature+caller changes to convert to map[string]struct{}. ~60+ non-test sites overall → not near-zero. Ask remains: add escape filter, re-measure residual local-only sites, then enforce. Issue still open (not duplicated).

Low / Informational findings

• tolowerequalfold enforce path: after the precision fix, ~15 genuine EqualFold opportunities remain (yaml_import.go:39, schema_suggestions.go:666, repo_memory_validation.go:52, features.go:69/105, resolve.go:173/189/227, notify_comment.go:630, strings.go:224, codespace.go:17, forecast.go:462, add_workflow_resolution.go:459, outcome_eval_review.go:79, import_url_fetcher.go:218) → not near-zero, enforce is a separate refactor.
• //nolint parity gap: fmterrorfnoverbs, seenmapbool, and tolowerequalfold all lack nolint.BuildLineIndex (no inline-suppression), unlike older siblings. A shared //nolint proposal would unblock enforcement of non-zero linters.
• seenmapbool double-processing: FuncDecl bodies are walked with ast.Inspect (which descends into nested FuncLits) and each FuncLit is separately visited — a map declared inside a closure could be reported twice. Minor; worth folding into the sg26a1 fix.
• Registry growth cadence: ~1 new linter per few runs (R23=18, R25=19, R26=20, R27=21).

✅ Improvement Task Generated

Task: fix tolowerequalfold self-comparison false-positive (sg27a1) — add caseConvArg/sameOperand filter, add okExamples fixtures for ToLower(x) == x and != x, keep flaggedExamples passing, re-run over pkg/+cmd/ to confirm the 3 FP sites drop while ~15 genuine sites remain. Severity High, effort Small.

📈 Success Metrics

Metric	Value
Findings	6
Issues created	1 (sg27a1)
Duplicates skipped	1 (sg26a1, still open)
Score	9/10

Reasoning: clean reverify confirming a prediction (streak stall), a high-impact correctness-affecting precision finding with a verified dangerous site, and a tightly-scoped single-file fix. Not 10 because the enforce pipeline is now stalling on hard linters with no landed remediation this run.

📊 Historical Context

• Total runs: 27 | Total findings: 216 | Total tasks: 53 | Avg score: 8.69
• Enforced linters: 11 (unchanged from R26) | Registered: 21
• Pattern note: the 5-run enforce-landing streak (R22→R26) ended at R27; near-zero linters land fast, non-near-zero ones don't. The precision-fix sub-pattern (single-file, self-consistency) is now the reliable landable angle for new linters.

🎯 Recommendations

1. Immediate: land sg27a1 (self-comparison filter) — prevents a dangerous mechanical fix and unblocks future tolowerequalfold enforcement.
2. Near-term: progress sg26a1 (seenmapbool escape filter) to shrink the convertible set toward enforceability.
3. Long-term: propose //nolint (BuildLineIndex) parity for the 3 newest linters so non-zero linters gain an incremental enforce path.

🔄 Next Run Preview (R28)

Reverify sg26a1 + sg27a1; watch for a 22nd linter. If neither precision fix lands, treat the enforce pipeline as saturated on hard linters and pivot to the 15-site EqualFold conversion or the //nolint parity proposal.

---

Generated by Sergo — The Serena Go Expert
Run ID: 26932367410 · Strategy: reverify-plus-new-tolowerequalfold-21st-linter-selfcompare-precision-audit

References: §26932367410

Generated by 🤖 Sergo - Serena Go Expert · opus48 10.2M · ◷

• expires on Jun 5, 2026, 5:26 AM UTC

[github-actions[bot]]

This discussion has been marked as outdated by Sergo - Serena Go Expert.

A newer discussion is available at Discussion #37062.