cache: make the sqlc binary an implicit input of every action

Version strings under-invalidate: every dev build reports the same
version, so a rebuilt sqlc with different analysis or codegen logic
would keep hitting entries produced by the old binary. Hash the running
executable once per process and mix it into every action digest as the
first input, the way Bazel treats the toolchain as action input.

This subsumes the explicit version, wazero version, and GOOS/GOARCH
inputs, which are all determined by the binary, so drop them.

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

Author: claude

internal/analyzer/analyzer.go

@@ -11,7 +11,6 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/analysis"
 	"github.com/sqlc-dev/sqlc/internal/cache"
 	"github.com/sqlc-dev/sqlc/internal/config"
-	"github.com/sqlc-dev/sqlc/internal/info"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 	"github.com/sqlc-dev/sqlc/internal/sql/named"
 )
@@ -66,10 +65,10 @@ func (c *CachedAnalyzer) analyze(ctx context.Context, n ast.Node, q string, sche
 		}
 	}
 
-	// Analyzing a query is an action whose inputs are the sqlc version, the
-	// configuration, the schema migrations, and the query itself.
+	// 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").
-		AddInput("version", []byte(info.Version)).
 		AddInput("config", c.configBytes)
 	for _, m := range schema {
 		action.AddInput("schema", []byte(m))

internal/cache/cache_test.go

@@ -134,6 +134,18 @@ func TestCASDeclaredChecksumLoad(t *testing.T) {
 	}
 }
 
+func TestToolDigest(t *testing.T) {
+	d := toolDigest()
+	if len(d) == 0 {
+		t.Fatal("toolDigest returned no bytes")
+	}
+	// The digest is hashed once and must be stable within a process, or
+	// identical actions would stop matching.
+	if string(toolDigest()) != string(d) {
+		t.Error("toolDigest is not stable across calls")
+	}
+}
+
 func TestActionDigestFraming(t *testing.T) {
 	a := NewAction("Test").AddInput("query", []byte("ab")).AddInput("schema", []byte("c"))
 	b := NewAction("Test").AddInput("query", []byte("a")).AddInput("schema", []byte("bc"))

internal/cache/digest.go

@@ -64,10 +64,14 @@ type Action struct {
 }
 
 // NewAction starts building an action key for the given mnemonic, e.g.
-// "QueryAnalysis".
+// "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 {
 	a := &Action{hasher: sha256.New()}
 	a.write([]byte(mnemonic))
+	a.AddInput("tool", toolDigest())
 	return a
 }
 

internal/cache/tool.go

@@ -0,0 +1,32 @@
+package cache
+
+import (
+	"crypto/sha256"
+	"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 {
+	path, err := os.Executable()
+	if err != nil {
+		return []byte(info.Version)
+	}
+	f, err := os.Open(path)
+	if err != nil {
+		return []byte(info.Version)
+	}
+	defer f.Close()
+	h := sha256.New()
+	if _, err := io.Copy(h, f); err != nil {
+		return []byte(info.Version)
+	}
+	return h.Sum(nil)
+})

internal/ext/wasm/wasm.go

@@ -11,7 +11,6 @@ import (
 	"net/http"
 	"os"
 	"runtime"
-	"runtime/debug"
 	"strings"
 
 	"github.com/tetratelabs/wazero"
@@ -135,16 +134,14 @@ func (r *Runner) loadAndCompileWASM(ctx context.Context, store *cache.Cache, exp
 		return nil, err
 	}
 
-	// Compiling the module to machine code is itself a cacheable action,
-	// keyed by the module's checksum and everything else that determines the
-	// generated code. Compiled artifacts are materialized into an exec
-	// directory for wazero's compilation cache to find; the authoritative
-	// copies live in the CAS.
+	// Compiling the module to machine code is itself a cacheable action.
+	// Its only declared input is the module's checksum: the embedded wazero
+	// version and the target platform are determined by the sqlc binary,
+	// 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").
 		AddInput("wasm", []byte(expected)).
-		AddInput("wazero", []byte(wazeroVersion())).
-		AddInput("goos", []byte(runtime.GOOS)).
-		AddInput("goarch", []byte(runtime.GOARCH)).
 		Digest()
 
 	execDir, err := store.ExecDir(compileAction)
@@ -187,20 +184,6 @@ func (r *Runner) loadAndCompileWASM(ctx context.Context, store *cache.Cache, exp
 	return &runtimeAndCode{rt: rt, code: code}, nil
 }
 
-// wazeroVersion returns the version of the wazero dependency, an input to
-// the CompileModule action: its generated machine code changes between
-// wazero releases.
-func wazeroVersion() string {
-	if bi, ok := debug.ReadBuildInfo(); ok {
-		for _, dep := range bi.Deps {
-			if dep.Path == "github.com/tetratelabs/wazero" {
-				return dep.Version
-			}
-		}
-	}
-	return info.Version
-}
-
 // removePGCatalog removes the pg_catalog schema from the request. There is a
 // mysterious (reason unknown) bug with wasm plugins when a large amount of
 // tables (like there are in the catalog) are sent.