cache: memoize the tool digest keyed by executable metadata

Hashing the ~100MB sqlc binary costs ~80ms, which every short-lived
sqlc process paid on its first action. Memoize the digest on disk keyed
by the executable's path, size, and mtime — the same trick as Bazel's
file digest cache — so a warm run costs a stat and a tiny read, and
only a rebuilt or moved binary is re-hashed. This puts warm-cache
generate times back on par with the pre-redesign cache (~32ms for a
WASM plugin run, previously ~100ms with per-process hashing).

The memo lives in the cache, so NewAction moves onto Cache.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MPgq3rwip76D554BktbqR4

Author: claude

internal/analyzer/analyzer.go

@@ -74,7 +74,7 @@ func (c *CachedAnalyzer) analyze(ctx context.Context, n ast.Node, q string, sche
 	// Analyzing a query is an action whose inputs are the configuration, the
 	// schema migrations, and the query itself. (The sqlc binary is an
 	// implicit input of every action.)
-	action := cache.NewAction("QueryAnalysis").
+	action := store.NewAction("QueryAnalysis").
 		AddInput("config", c.configBytes)
 	for _, m := range schema {
 		action.AddInput("schema", []byte(m))

internal/cache/digest.go

@@ -67,11 +67,12 @@ type Action struct {
 // "QueryAnalysis". The sha256 of the sqlc binary itself is always the first
 // input: the tool that executes an action determines its outputs just as
 // much as the declared inputs do, so a rebuilt sqlc never reuses stale
-// entries.
-func NewAction(mnemonic string) *Action {
+// entries. The binary's digest is memoized in the cache — see toolDigest —
+// which is why actions are created through a Cache.
+func (c *Cache) NewAction(mnemonic string) *Action {
 	a := &Action{hasher: sha256.New()}
 	a.write([]byte(mnemonic))
-	a.AddInput("tool", toolDigest())
+	a.AddInput("tool", c.toolDigest())
 	return a
 }
 

internal/cache/tool.go

@@ -2,23 +2,68 @@ package cache
 
 import (
 	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
 	"io"
 	"os"
 	"sync"
 
 	"github.com/sqlc-dev/sqlc/internal/info"
 )
 
-// toolDigest returns the sha256 of the running sqlc binary, hashed once per
-// process. The binary is an input to every action — a rebuilt sqlc may
-// analyze queries or embed a different wazero than the one that produced a
-// cache entry, even when the version string is unchanged (dev builds). If
-// the executable can't be read, fall back to the version string.
-var toolDigest = sync.OnceValue(func() []byte {
+// The sha256 of the sqlc binary is an input to every action — a rebuilt sqlc
+// may analyze queries or embed a different wazero than the one that produced
+// a cache entry, even when the version string is unchanged (dev builds).
+//
+// Hashing a ~100MB executable costs tens of milliseconds, too much to pay on
+// every short-lived sqlc process, so the digest is memoized on disk keyed by
+// the executable's path, size, and mtime — the same trick Bazel's file
+// digest cache uses. A warm run costs one stat and a tiny read; only a
+// rebuilt (or moved) binary is re-hashed.
+var tool struct {
+	sync.Mutex
+	digest []byte
+}
+
+type toolMemo struct {
+	Path      string `json:"path"`
+	SizeBytes int64  `json:"size_bytes"`
+	MtimeNS   int64  `json:"mtime_ns"`
+	SHA256    string `json:"sha256"`
+}
+
+const toolMemoPath = "tool"
+
+func (c *Cache) toolDigest() []byte {
+	tool.Lock()
+	defer tool.Unlock()
+	if tool.digest == nil {
+		tool.digest = c.computeToolDigest()
+	}
+	return tool.digest
+}
+
+func (c *Cache) computeToolDigest() []byte {
 	path, err := os.Executable()
 	if err != nil {
 		return []byte(info.Version)
 	}
+	fi, err := os.Stat(path)
+	if err != nil {
+		return []byte(info.Version)
+	}
+
+	var memo toolMemo
+	if data, err := c.root.ReadFile(toolMemoPath); err == nil {
+		if err := json.Unmarshal(data, &memo); err == nil &&
+			memo.Path == path &&
+			memo.SizeBytes == fi.Size() &&
+			memo.MtimeNS == fi.ModTime().UnixNano() &&
+			memo.SHA256 != "" {
+			return []byte(memo.SHA256)
+		}
+	}
+
 	f, err := os.Open(path)
 	if err != nil {
 		return []byte(info.Version)
@@ -28,5 +73,23 @@ var toolDigest = sync.OnceValue(func() []byte {
 	if _, err := io.Copy(h, f); err != nil {
 		return []byte(info.Version)
 	}
-	return h.Sum(nil)
-})
+	sum := hex.EncodeToString(h.Sum(nil))
+
+	memo = toolMemo{
+		Path:      path,
+		SizeBytes: fi.Size(),
+		MtimeNS:   fi.ModTime().UnixNano(),
+		SHA256:    sum,
+	}
+	if data, err := json.Marshal(memo); err == nil {
+		if f, name, err := c.CAS.createTemp("tool-"); err == nil {
+			if _, werr := f.Write(data); werr == nil && f.Close() == nil {
+				c.root.Rename(name, toolMemoPath)
+			} else {
+				f.Close()
+			}
+			c.root.Remove(name)
+		}
+	}
+	return []byte(sum)
+}

internal/ext/wasm/wasm.go

@@ -141,7 +141,7 @@ func (r *Runner) loadAndCompileWASM(ctx context.Context, store *cache.Cache, exp
 	// which is an implicit input of every action. Compiled artifacts are
 	// materialized into an exec directory for wazero's compilation cache to
 	// find; the authoritative copies live in the CAS.
-	compileAction := cache.NewAction("CompileModule").
+	compileAction := store.NewAction("CompileModule").
 		AddInput("wasm", []byte(expected)).
 		Digest()