cmd/go: only invalidate coverage report cache when coverpkg sources change

When using -coverpkg, test caching could return stale coverage data
if covered packages were modified but the test package itself was
unchanged. This occurred because the test cache didn't track changes
to packages specified by -coverpkg.

This change adds selective cache invalidation by moving covered package
tracking from the main test cache to only the coverage report cache:

- Add hashCoveredPackages function to hash source files of covered packages
- Modify coverProfileAndInputKey to include covered packages hash
- Add test case to verify coverage report cache invalidation works correctly

When any file in a covered package changes, only the coverage report
cache is invalidated while test results remain cached, improving
performance while ensuring fresh coverage data is generated.

Fixes issue where coverage reports contained duplicate entries with
different line ranges after source modifications in covered packages.

Fixes #74873

Author: ryancurrah

src/cmd/go/internal/test/test.go

@@ -1927,6 +1927,25 @@ func (c *runCache) tryCacheWithID(b *work.Builder, a *work.Action, id string) bo
 var errBadTestInputs = errors.New("error parsing test inputs")
 var testlogMagic = []byte("# test log\n") // known to testing/internal/testdeps/deps.go
 
+// hashCoveredPackages writes to h a hash of the source files of the covered packages.
+func hashCoveredPackages(h io.Writer, pkgs []*load.Package) {
+	for _, pkg := range pkgs {
+		fmt.Fprintf(h, "coverpkg %s", pkg.ImportPath)
+		// Include source file hashes to detect changes
+		for _, file := range pkg.GoFiles {
+			if fh := hashStat(filepath.Join(pkg.Dir, file)); fh != (cache.ActionID{}) {
+				fmt.Fprintf(h, " %x", fh)
+			}
+		}
+		for _, file := range pkg.CgoFiles {
+			if fh := hashStat(filepath.Join(pkg.Dir, file)); fh != (cache.ActionID{}) {
+				fmt.Fprintf(h, " %x", fh)
+			}
+		}
+		fmt.Fprintf(h, "\n")
+	}
+}
+
 // computeTestInputsID computes the "test inputs ID"
 // (see comment in tryCacheWithID above) for the
 // test log.
@@ -2071,7 +2090,11 @@ func testAndInputKey(testID, testInputsID cache.ActionID) cache.ActionID {
 
 // coverProfileAndInputKey returns the "coverprofile" cache key for the pair (testID, testInputsID).
 func coverProfileAndInputKey(testID, testInputsID cache.ActionID) cache.ActionID {
-	return cache.Subkey(testAndInputKey(testID, testInputsID), "coverprofile")
+	// Include covered packages hash to invalidate coverage reports when covered packages change
+	h := cache.NewHash("coverprofile")
+	h.Write(testAndInputKey(testID, testInputsID)[:])
+	hashCoveredPackages(h, testCoverPkgs)
+	return h.Sum()
 }
 
 func (c *runCache) saveOutput(a *work.Action) {

src/cmd/go/testdata/script/test_cache_coverpkg_bug.txt

@@ -0,0 +1,137 @@
+env GO111MODULE=on
+
+# Test for bug where cached coverage profiles with -coverpkg can contain
+# outdated line references when source files are modified.
+# This reproduces the issue where coverage data from cache may reference
+# lines that no longer exist in the updated source files.
+
+[short] skip
+[GODEBUG:gocacheverify=1] skip
+
+# We're testing cache behavior, so start with a clean GOCACHE.
+env GOCACHE=$WORK/cache
+
+# Create a project structure with multiple packages
+# proj/
+#   some_func.go
+#   some_func_test.go
+#   sub/
+#     sub.go
+#     sub_test.go
+#   sum/
+#     sum.go
+
+# Switch to the proj directory
+cd proj
+
+# Run tests with -coverpkg to collect coverage for all packages
+go test -coverpkg=proj/... -coverprofile=cover1.out ./...
+stdout 'coverage:'
+
+# Verify the first coverage profile exists and has expected content
+exists cover1.out
+grep -q 'proj/sub/sub.go:' cover1.out
+
+# Run again to ensure caching works
+go test -coverpkg=proj/... -coverprofile=cover1_cached.out ./...
+stdout '\(cached\)'
+stdout 'coverage:'
+
+# Note: Due to the bug, cached coverage profiles may have duplicate entries
+# This is the issue we're trying to fix
+
+# Now modify sub.go to change line structure - this will invalidate
+# the cache for sub package but not for proj package
+cp ../sub_modified.go sub/sub.go
+
+# The bug manifests as duplicate or invalid line references in the coverage profile
+# After modifying sub.go, we should not have both old and new line references
+go test -coverpkg=proj/... -coverprofile=cover2.out ./...
+stdout 'coverage:'
+
+# With the bug present, we would see duplicate entries for the same lines
+# This demonstrates the bug - there should be duplicates in the coverage profile
+grep 'proj/sub/sub.go:' cover2.out
+# The fix should ensure that only the new line format exists, not the old one
+grep 'proj/sub/sub.go:3.24,4.35' cover2.out
+# This should fail if the stale coverage line exists (the bug is present)
+! grep 'proj/sub/sub.go:3.24,4.22' cover2.out
+
+-- proj/go.mod --
+module proj
+
+go 1.21
+
+-- proj/some_func.go --
+package proj
+
+import "proj/sum"
+
+func SomeFunc(a, b int) int {
+	if a == 0 && b == 0 {
+		return 0
+	}
+	return sum.Sum(a, b)
+}
+
+-- proj/some_func_test.go --
+package proj
+
+import (
+	"testing"
+)
+
+func Test_SomeFunc(t *testing.T) {
+	t.Run("test1", func(t *testing.T) {
+		result := SomeFunc(1, 1)
+		if result != 2 {
+			t.Errorf("Expected 2, got %d", result)
+		}
+	})
+}
+
+-- proj/sub/sub.go --
+package sub
+
+func Sub(a, b int) int {
+	if a == 0 && b == 0 {
+		return 0
+	}
+	return a - b
+}
+
+-- proj/sub/sub_test.go --
+package sub
+
+import (
+	"testing"
+)
+
+func Test_Sub(t *testing.T) {
+	t.Run("test_sub1", func(t *testing.T) {
+		result := Sub(1, 1)
+		if result != 0 {
+			t.Errorf("Expected 0, got %d", result)
+		}
+	})
+}
+
+-- proj/sum/sum.go --
+package sum
+
+func Sum(a, b int) int {
+	if a == 0 {
+		return b
+	}
+	return a + b
+}
+
+-- sub_modified.go --
+package sub
+
+func Sub(a, b int) int {
+	if a == 0 && b == 0 || a == -100 {
+		return 0
+	}
+	return a - b
+}

test_coverage_cache.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+
+# Test script to verify that coverage cache invalidation works correctly
+# when coverpkg sources change but only invalidates coverage reports, not all cache
+
+set -e
+
+export PATH=/Users/ryancurrah/git/github.com/ryancurrah/go/bin:$PATH
+export GOCACHE=/tmp/test_cache_$$
+mkdir -p $GOCACHE
+
+echo "Creating test project..."
+mkdir -p /tmp/test_proj_$$/{sub,sum}
+cd /tmp/test_proj_$$
+
+# Create go.mod
+cat > go.mod << EOF
+module test_proj
+
+go 1.21
+EOF
+
+# Create main package
+cat > some_func.go << 'EOF'
+package main
+
+import "test_proj/sum"
+
+func SomeFunc(a, b int) int {
+    if a == 0 && b == 0 {
+        return 0
+    }
+    return sum.Sum(a, b)
+}
+
+func main() {}
+EOF
+
+cat > some_func_test.go << 'EOF' 
+package main
+
+import "testing"
+
+func Test_SomeFunc(t *testing.T) {
+    result := SomeFunc(1, 1)
+    if result != 2 {
+        t.Errorf("Expected 2, got %d", result)
+    }
+}
+EOF
+
+# Create sub package
+cat > sub/sub.go << 'EOF'
+package sub
+
+func Sub(a, b int) int {
+    if a == 0 && b == 0 {
+        return 0
+    }
+    return a - b
+}
+EOF
+
+cat > sub/sub_test.go << 'EOF'
+package sub
+
+import "testing"
+
+func Test_Sub(t *testing.T) {
+    result := Sub(1, 1)
+    if result != 0 {
+        t.Errorf("Expected 0, got %d", result)
+    }
+}
+EOF
+
+# Create sum package  
+cat > sum/sum.go << 'EOF'
+package sum
+
+func Sum(a, b int) int {
+    if a == 0 {
+        return b
+    }
+    return a + b
+}
+EOF
+
+echo "Running initial test with coverage..."
+go test -coverpkg=./... -coverprofile=cover1.out ./... -v
+
+echo "Running test again to check caching..."
+go test -coverpkg=./... -coverprofile=cover2.out ./... -v
+
+echo "Modifying sub/sub.go..."
+cat > sub/sub.go << 'EOF'
+package sub
+
+func Sub(a, b int) int {
+    if a == 0 && b == 0 || a == -100 {
+        return 0
+    }
+    return a - b
+}
+EOF
+
+echo "Running test after modification..."
+go test -coverpkg=./... -coverprofile=cover3.out ./... -v
+
+echo "Test completed successfully!"
+
+# Cleanup
+cd /
+rm -rf /tmp/test_proj_$$
+rm -rf $GOCACHE
+
+echo "Coverage cache test passed!"