fix(checklocks): enhance diagnostics and deduplication in failure reporting

This change aims to improve the clarity and accuracy of failure reporting in the analysis tool, reducing noise in diagnostics.

Previous output:
```text
-: return with unexpected locks held (locks: &({param:s}.mu) exclusively)
-: return with unexpected locks held (locks: &(*(&({*ssa.Call:0x14003d9fe80}.trace)).mu) exclusively)
-: return with unexpected locks held (locks: &(*(&({*ssa.Call:0x14003db0a00}.trace)).mu) exclusively)
-: return with unexpected locks held (locks: &(*(&({*ssa.Call:0x14003db1600}[0].trace)).mu) exclusively)
```

Current output:
```text
# gvisor.dev/gvisor/tools/checklocks/test
test/basics.go:130:6: return with unexpected locks held (locks: &({param:tc}.mu) exclusively)
test/methods.go:95:6: lock a.mu (&({param:a}.mu)) not held exclusively (locks: no locks held)
````

- Introduced a mechanism to track the current function during checks for improved diagnostics when SSA positions are missing.
- Enhanced the `maybeFail` function to build a message string for deduplication, ensuring identical diagnostics are not reported multiple times for the same position key.
- Updated the `passContext` struct to include a new `reported` map for tracking reported messages.

Signed-off-by: Kemal Akkoyun <[email protected]>
FUTURE_COPYBARA_INTEGRATE_REVIEW=#11741 from kakkoyun:existing_issues 3f8b63f
PiperOrigin-RevId: 761287214

Author: kakkoyun

tools/checklocks/analysis.go

@@ -777,6 +777,11 @@ func (pc *passContext) checkBasicBlock(fn *ssa.Function, block *ssa.BasicBlock,
 
 // checkFunction checks a function invocation, typically starting with nil lockState.
 func (pc *passContext) checkFunction(call callCommon, fn *ssa.Function, lff *lockFunctionFacts, parent *lockState, force bool) {
+	// Track current function for diagnostics when SSA positions are missing.
+	prevFn := pc.curFn
+	pc.curFn = fn
+	defer func() { pc.curFn = prevFn }()
+
 	defer func() {
 		// Mark this function as checked. This is used by the top-level
 		// loop to ensure that all anonymous functions are scanned, if

tools/checklocks/annotations.go

@@ -84,17 +84,41 @@ func (pc *passContext) addForce(pos token.Pos) {
 
 // maybeFail checks a potential failure against a specific failure map.
 func (pc *passContext) maybeFail(pos token.Pos, fmtStr string, args ...any) {
-	if fd, ok := pc.failures[pc.positionKey(pos)]; ok {
+	// Build the message string to allow deduplication.
+	msg := fmt.Sprintf(fmtStr, args...)
+
+	origPos := pos
+	reportPos := pos
+	if !pos.IsValid() && pc.curFn != nil {
+		reportPos = pc.curFn.Pos()
+	}
+
+	key := pc.positionKey(origPos)
+
+	// Deduplicate: if we already reported this exact message for the same
+	// position key, ignore subsequent identical diagnostics so they donʼt
+	// affect failure-count logic.
+	if seenMsgs, ok := pc.reported[key]; ok {
+		if _, dup := seenMsgs[msg]; dup {
+			return
+		}
+	} else {
+		pc.reported[key] = make(map[string]struct{})
+	}
+
+	pc.reported[key][msg] = struct{}{}
+
+	if fd, ok := pc.failures[key]; ok {
 		fd.seen++
 		return
 	}
-	if _, ok := pc.exemptions[pc.positionKey(pos)]; ok {
+	if _, ok := pc.exemptions[key]; ok {
 		return // Ignored, not counted.
 	}
-	if !enableWrappers && !pos.IsValid() {
+	if !enableWrappers && !origPos.IsValid() {
 		return // Ignored, implicit.
 	}
-	pc.pass.Reportf(pos, fmtStr, args...)
+	pc.pass.Reportf(reportPos, fmtStr, args...)
 }
 
 // checkFailure checks for the expected failure counts.

tools/checklocks/checklocks.go

@@ -73,7 +73,9 @@ type passContext struct {
 	failures     map[positionKey]*failData
 	exemptions   map[positionKey]struct{}
 	forced       map[positionKey]struct{}
+	reported     map[positionKey]map[string]struct{}
 	functions    map[*ssa.Function]struct{}
+	curFn        *ssa.Function
 	observations map[types.Object]*objectObservations
 }
 
@@ -143,6 +145,7 @@ func run(pass *analysis.Pass) (any, error) {
 		exemptions: make(map[positionKey]struct{}),
 		forced:     make(map[positionKey]struct{}),
 		functions:  make(map[*ssa.Function]struct{}),
+		reported:   make(map[positionKey]map[string]struct{}),
 	}
 
 	// Find all line failure annotations.