fix nil interface panic

Author: mmsqe

internal/blockstm/storage.go

@@ -45,17 +45,20 @@ type GCachedStorage[V any] struct {
 	cache sync.Map
 }
 
+// cacheEntry boxes V so a cached zero-value any never reaches sync.Map as a nil interface.
+type cacheEntry[V any] struct{ v V }
+
 func NewGCachedStorage[V any](storage GStorage[V]) *GCachedStorage[V] {
 	return &GCachedStorage[V]{GStorage: storage}
 }
 
 func (s *GCachedStorage[V]) Get(key []byte) V {
-	if v, ok := s.cache.Load(string(key)); ok {
-		return v.(V)
+	if e, ok := s.cache.Load(string(key)); ok {
+		return e.(cacheEntry[V]).v
 	}
 
 	v := s.GStorage.Get(key)
-	s.cache.Store(string(key), v)
+	s.cache.Store(string(key), cacheEntry[V]{v: v})
 	return v
 }
 

internal/blockstm/storage_test.go

@@ -0,0 +1,46 @@
+package blockstm
+
+import (
+	"sync/atomic"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestGCachedStorage covers hit/miss memoization for both V=[]byte and V=any,
+// the ObjKV case is a regression guard against the nil-interface assertion panic.
+func TestGCachedStorage(t *testing.T) {
+	t.Run("KV", func(t *testing.T) {
+		parent := NewMemDB()
+		parent.Set([]byte("k"), []byte("v"))
+		assertCache(t, parent, []byte("v"), nil)
+	})
+
+	t.Run("ObjKV", func(t *testing.T) {
+		parent := NewObjMemDB()
+		parent.Set([]byte("k"), "v")
+		assertCache(t, parent, "v", nil)
+	})
+}
+
+func assertCache[V any](t *testing.T, parent GStorage[V], hitValue, missValue V) {
+	t.Helper()
+	counted := &countingStorage[V]{GStorage: parent}
+	cached := NewGCachedStorage(counted)
+
+	for i := 0; i < 3; i++ {
+		require.Equal(t, hitValue, cached.Get([]byte("k")))
+		require.Equal(t, missValue, cached.Get([]byte("missing")))
+	}
+	require.EqualValues(t, 2, counted.gets.Load(), "each distinct key reads parent exactly once")
+}
+
+type countingStorage[V any] struct {
+	GStorage[V]
+	gets atomic.Int64
+}
+
+func (c *countingStorage[V]) Get(key []byte) V {
+	c.gets.Add(1)
+	return c.GStorage.Get(key)
+}