fix(cmd/go): only invalidate coverage cache when coverpkg sources change

Instead of invalidating all test cache when covered packages change,
only invalidate the coverage report cache. This improves performance
by allowing test results to remain cached while ensuring coverage
reports are updated when covered packages are modified.

- Remove covered packages hash from main test ID calculation
- Move coverage invalidation to coverProfileAndInputKey function
- Remove unnecessary build dependencies for covered packages

Fixes #74873

Author: ryancurrah

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

@@ -1290,8 +1290,7 @@ func builderTest(b *work.Builder, ctx context.Context, pkgOpts load.PackageOpts,
 				// Add a dependence edge from p to writeCoverMetaAct,
 				// which needs to know the name of that meta-data
 				// file.
-				compileAction := b.CompileAction(work.ModeBuild, work.ModeBuild, p)
-				writeCoverMetaAct.Deps = append(writeCoverMetaAct.Deps, compileAction)
+				writeCoverMetaAct.Deps = append(writeCoverMetaAct.Deps, b.CompileAction(work.ModeBuild, work.ModeBuild, p))
 			}
 		}
 		runAction.Objdir = testDir
@@ -1927,6 +1926,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 +2089,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
+}