cmd/go/internal/par: use generic Cache

Using generics here makes the code easier to understand,
as the contract is clearly specified. It also makes the
code a little more concise, as it's easy to write a wrapper
for the cache that adds an error value, meaning that
a bunch of auxilliary types no longer need to be defined
for this common case.

The load.cachingRepo code has been changed to use a separate
cache for each key-value type combination, which seems a bit less
sleazy, but might have some knock-on effect on memory usage,
and could easily be changed back if desired.

Because there's no longer an unambiguous way to find out
whether there's an entry in the cache, the Cache.Get method
now returns a bool as well as the value itself.

Change-Id: I28443125bab0b3720cc95d750e72d28e9b96257d
Reviewed-on: https://go-review.googlesource.com/c/go/+/463843
Reviewed-by: Bryan Mills <[email protected]>
Run-TryBot: roger peppe <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Reviewed-by: Michael Knyszek <[email protected]>

Author: rogpeppe

src/cmd/go/internal/load/pkg.go

@@ -612,11 +612,11 @@ func ClearPackageCachePartial(args []string) {
 			delete(packageCache, arg)
 		}
 	}
-	resolvedImportCache.DeleteIf(func(key any) bool {
-		return shouldDelete[key.(importSpec).path]
+	resolvedImportCache.DeleteIf(func(key importSpec) bool {
+		return shouldDelete[key.path]
 	})
-	packageDataCache.DeleteIf(func(key any) bool {
-		return shouldDelete[key.(string)]
+	packageDataCache.DeleteIf(func(key string) bool {
+		return shouldDelete[key]
 	})
 }
 
@@ -628,8 +628,8 @@ func ReloadPackageNoFlags(arg string, stk *ImportStack) *Package {
 	p := packageCache[arg]
 	if p != nil {
 		delete(packageCache, arg)
-		resolvedImportCache.DeleteIf(func(key any) bool {
-			return key.(importSpec).path == p.ImportPath
+		resolvedImportCache.DeleteIf(func(key importSpec) bool {
+			return key.path == p.ImportPath
 		})
 		packageDataCache.Delete(p.ImportPath)
 	}
@@ -846,7 +846,7 @@ func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoo
 		parentIsStd: parentIsStd,
 		mode:        mode,
 	}
-	r := resolvedImportCache.Do(importKey, func() any {
+	r := resolvedImportCache.Do(importKey, func() resolvedImport {
 		var r resolvedImport
 		if cfg.ModulesEnabled {
 			r.dir, r.path, r.err = modload.Lookup(parentPath, parentIsStd, path)
@@ -866,16 +866,19 @@ func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoo
 			r.path = path
 		}
 		return r
-	}).(resolvedImport)
+	})
 	// Invariant: r.path is set to the resolved import path. If the path cannot
 	// be resolved, r.path is set to path, the source import path.
 	// r.path is never empty.
 
 	// Load the package from its directory. If we already found the package's
 	// directory when resolving its import path, use that.
-	data := packageDataCache.Do(r.path, func() any {
+	p, err := packageDataCache.Do(r.path, func() (*build.Package, error) {
 		loaded = true
-		var data packageData
+		var data struct {
+			p   *build.Package
+			err error
+		}
 		if r.dir != "" {
 			var buildMode build.ImportMode
 			buildContext := cfg.BuildContext
@@ -961,10 +964,10 @@ func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoo
 			!strings.Contains(path, "/vendor/") && !strings.HasPrefix(path, "vendor/") {
 			data.err = fmt.Errorf("code in directory %s expects import %q", data.p.Dir, data.p.ImportComment)
 		}
-		return data
-	}).(packageData)
+		return data.p, data.err
+	})
 
-	return data.p, loaded, data.err
+	return p, loaded, err
 }
 
 // importSpec describes an import declaration in source code. It is used as a
@@ -984,20 +987,11 @@ type resolvedImport struct {
 	err       error
 }
 
-// packageData holds information loaded from a package. It is the value type
-// in packageDataCache.
-type packageData struct {
-	p   *build.Package
-	err error
-}
-
-// resolvedImportCache maps import strings (importSpec) to canonical package names
-// (resolvedImport).
-var resolvedImportCache par.Cache
+// resolvedImportCache maps import strings to canonical package names.
+var resolvedImportCache par.Cache[importSpec, resolvedImport]
 
-// packageDataCache maps canonical package names (string) to package metadata
-// (packageData).
-var packageDataCache par.Cache
+// packageDataCache maps canonical package names (string) to package metadata.
+var packageDataCache par.ErrCache[string, *build.Package]
 
 // preloadWorkerCount is the number of concurrent goroutines that can load
 // packages. Experimentally, there are diminishing returns with more than
@@ -1109,13 +1103,13 @@ func cleanImport(path string) string {
 	return path
 }
 
-var isDirCache par.Cache
+var isDirCache par.Cache[string, bool]
 
 func isDir(path string) bool {
-	return isDirCache.Do(path, func() any {
+	return isDirCache.Do(path, func() bool {
 		fi, err := fsys.Stat(path)
 		return err == nil && fi.IsDir()
-	}).(bool)
+	})
 }
 
 // ResolveImportPath returns the true meaning of path when it appears in parent.
@@ -1236,12 +1230,12 @@ func vendoredImportPath(path, parentPath, parentDir, parentRoot string) (found s
 
 var (
 	modulePrefix   = []byte("\nmodule ")
-	goModPathCache par.Cache
+	goModPathCache par.Cache[string, string]
 )
 
 // goModPath returns the module path in the go.mod in dir, if any.
 func goModPath(dir string) (path string) {
-	return goModPathCache.Do(dir, func() any {
+	return goModPathCache.Do(dir, func() string {
 		data, err := os.ReadFile(filepath.Join(dir, "go.mod"))
 		if err != nil {
 			return ""
@@ -1277,7 +1271,7 @@ func goModPath(dir string) (path string) {
 			path = s
 		}
 		return path
-	}).(string)
+	})
 }
 
 // findVersionElement returns the slice indices of the final version element /vN in path.
@@ -2264,8 +2258,8 @@ func (p *Package) collectDeps() {
 }
 
 // vcsStatusCache maps repository directories (string)
-// to their VCS information (vcsStatusError).
-var vcsStatusCache par.Cache
+// to their VCS information.
+var vcsStatusCache par.ErrCache[string, vcs.Status]
 
 // setBuildInfo gathers build information, formats it as a string to be
 // embedded in the binary, then sets p.Internal.BuildInfo to that string.
@@ -2517,19 +2511,13 @@ func (p *Package) setBuildInfo(autoVCS bool) {
 			goto omitVCS
 		}
 
-		type vcsStatusError struct {
-			Status vcs.Status
-			Err    error
-		}
-		cached := vcsStatusCache.Do(repoDir, func() any {
-			st, err := vcsCmd.Status(vcsCmd, repoDir)
-			return vcsStatusError{st, err}
-		}).(vcsStatusError)
-		if err := cached.Err; err != nil {
+		st, err := vcsStatusCache.Do(repoDir, func() (vcs.Status, error) {
+			return vcsCmd.Status(vcsCmd, repoDir)
+		})
+		if err != nil {
 			setVCSError(err)
 			return
 		}
-		st := cached.Status
 
 		appendSetting("vcs", vcsCmd.Cmd)
 		if st.Revision != "" {

src/cmd/go/internal/modfetch/cache.go

@@ -169,8 +169,11 @@ func SideLock() (unlock func(), err error) {
 // (so that it can be returned from Lookup multiple times).
 // It serializes calls to the underlying Repo.
 type cachingRepo struct {
-	path  string
-	cache par.Cache // cache for all operations
+	path          string
+	versionsCache par.ErrCache[string, *Versions]
+	statCache     par.ErrCache[string, *RevInfo]
+	latestCache   par.ErrCache[struct{}, *RevInfo]
+	gomodCache    par.ErrCache[string, []byte]
 
 	once     sync.Once
 	initRepo func() (Repo, error)
@@ -204,23 +207,17 @@ func (r *cachingRepo) ModulePath() string {
 }
 
 func (r *cachingRepo) Versions(prefix string) (*Versions, error) {
-	type cached struct {
-		v   *Versions
-		err error
-	}
-	c := r.cache.Do("versions:"+prefix, func() any {
-		v, err := r.repo().Versions(prefix)
-		return cached{v, err}
-	}).(cached)
+	v, err := r.versionsCache.Do(prefix, func() (*Versions, error) {
+		return r.repo().Versions(prefix)
+	})
 
-	if c.err != nil {
-		return nil, c.err
-	}
-	v := &Versions{
-		Origin: c.v.Origin,
-		List:   append([]string(nil), c.v.List...),
+	if err != nil {
+		return nil, err
 	}
-	return v, nil
+	return &Versions{
+		Origin: v.Origin,
+		List:   append([]string(nil), v.List...),
+	}, nil
 }
 
 type cachedInfo struct {
@@ -229,10 +226,10 @@ type cachedInfo struct {
 }
 
 func (r *cachingRepo) Stat(rev string) (*RevInfo, error) {
-	c := r.cache.Do("stat:"+rev, func() any {
+	info, err := r.statCache.Do(rev, func() (*RevInfo, error) {
 		file, info, err := readDiskStat(r.path, rev)
 		if err == nil {
-			return cachedInfo{info, nil}
+			return info, err
 		}
 
 		info, err = r.repo().Stat(rev)
@@ -241,79 +238,70 @@ func (r *cachingRepo) Stat(rev string) (*RevInfo, error) {
 			// then save the information under the proper version, for future use.
 			if info.Version != rev {
 				file, _ = CachePath(module.Version{Path: r.path, Version: info.Version}, "info")
-				r.cache.Do("stat:"+info.Version, func() any {
-					return cachedInfo{info, err}
+				r.statCache.Do(info.Version, func() (*RevInfo, error) {
+					return info, nil
 				})
 			}
 
 			if err := writeDiskStat(file, info); err != nil {
 				fmt.Fprintf(os.Stderr, "go: writing stat cache: %v\n", err)
 			}
 		}
-		return cachedInfo{info, err}
-	}).(cachedInfo)
-
-	info := c.info
+		return info, err
+	})
 	if info != nil {
 		copy := *info
 		info = &copy
 	}
-	return info, c.err
+	return info, err
 }
 
 func (r *cachingRepo) Latest() (*RevInfo, error) {
-	c := r.cache.Do("latest:", func() any {
+	info, err := r.latestCache.Do(struct{}{}, func() (*RevInfo, error) {
 		info, err := r.repo().Latest()
 
 		// Save info for likely future Stat call.
 		if err == nil {
-			r.cache.Do("stat:"+info.Version, func() any {
-				return cachedInfo{info, err}
+			r.statCache.Do(info.Version, func() (*RevInfo, error) {
+				return info, nil
 			})
 			if file, _, err := readDiskStat(r.path, info.Version); err != nil {
 				writeDiskStat(file, info)
 			}
 		}
 
-		return cachedInfo{info, err}
-	}).(cachedInfo)
-
-	info := c.info
+		return info, err
+	})
 	if info != nil {
 		copy := *info
 		info = &copy
 	}
-	return info, c.err
+	return info, err
 }
 
 func (r *cachingRepo) GoMod(version string) ([]byte, error) {
-	type cached struct {
-		text []byte
-		err  error
-	}
-	c := r.cache.Do("gomod:"+version, func() any {
+	text, err := r.gomodCache.Do(version, func() ([]byte, error) {
 		file, text, err := readDiskGoMod(r.path, version)
 		if err == nil {
 			// Note: readDiskGoMod already called checkGoMod.
-			return cached{text, nil}
+			return text, nil
 		}
 
 		text, err = r.repo().GoMod(version)
 		if err == nil {
 			if err := checkGoMod(r.path, version, text); err != nil {
-				return cached{text, err}
+				return text, err
 			}
 			if err := writeDiskGoMod(file, text); err != nil {
 				fmt.Fprintf(os.Stderr, "go: writing go.mod cache: %v\n", err)
 			}
 		}
-		return cached{text, err}
-	}).(cached)
-
-	if c.err != nil {
-		return nil, c.err
+		return text, err
+	})
+	if err != nil {
+		return nil, err
 	}
-	return append([]byte(nil), c.text...), nil
+	return append([]byte(nil), text...), nil
 }
 
 func (r *cachingRepo) Zip(dst io.Writer, version string) error {

src/cmd/go/internal/modfetch/codehost/git.go

@@ -46,24 +46,17 @@ func (notExistError) Is(err error) bool { return err == fs.ErrNotExist }
 
 const gitWorkDirType = "git3"
 
-var gitRepoCache par.Cache
+var gitRepoCache par.ErrCache[gitCacheKey, Repo]
 
-func newGitRepoCached(remote string, localOK bool) (Repo, error) {
-	type key struct {
-		remote  string
-		localOK bool
-	}
-	type cached struct {
-		repo Repo
-		err  error
-	}
-
-	c := gitRepoCache.Do(key{remote, localOK}, func() any {
-		repo, err := newGitRepo(remote, localOK)
-		return cached{repo, err}
-	}).(cached)
+type gitCacheKey struct {
+	remote  string
+	localOK bool
+}
 
-	return c.repo, c.err
+func newGitRepoCached(remote string, localOK bool) (Repo, error) {
+	return gitRepoCache.Do(gitCacheKey{remote, localOK}, func() (Repo, error) {
+		return newGitRepo(remote, localOK)
+	})
 }
 
 func newGitRepo(remote string, localOK bool) (Repo, error) {
@@ -132,7 +125,7 @@ type gitRepo struct {
 
 	fetchLevel int
 
-	statCache par.Cache
+	statCache par.ErrCache[string, *RevInfo]
 
 	refsOnce sync.Once
 	// refs maps branch and tag refs (e.g., "HEAD", "refs/heads/master")
@@ -637,15 +630,9 @@ func (r *gitRepo) Stat(rev string) (*RevInfo, error) {
 	if rev == "latest" {
 		return r.Latest()
 	}
-	type cached struct {
-		info *RevInfo
-		err  error
-	}
-	c := r.statCache.Do(rev, func() any {
-		info, err := r.stat(rev)
-		return cached{info, err}
-	}).(cached)
-	return c.info, c.err
+	return r.statCache.Do(rev, func() (*RevInfo, error) {
+		return r.stat(rev)
+	})
 }
 
 func (r *gitRepo) ReadFile(rev, file string, maxSize int64) ([]byte, error) {