adding changed indicator and encoder/decoder

Author: grantnelson-wf

build/build.go

@@ -1084,7 +1084,7 @@ func (s *Session) LoadPackages(pkg *PackageData) (*sources.Sources, error) {
 	var srcs *sources.Sources
 	if s.buildCache != nil {
 		cachedSrcs := &sources.Sources{
-			CacheData: compiler.NewDeclCache(true),
+			DeclCache: compiler.NewDeclCache(true),
 		}
 		if s.buildCache.Load(cachedSrcs, pkg.ImportPath, pkg.SrcModTime) {
 			srcs = cachedSrcs
@@ -1113,7 +1113,7 @@ func (s *Session) LoadPackages(pkg *PackageData) (*sources.Sources, error) {
 			Files:      files,
 			FileSet:    fileSet,
 			JSFiles:    append(pkg.JSFiles, overlayJsFiles...),
-			CacheData:  compiler.NewDeclCache(s.buildCache != nil),
+			DeclCache:  compiler.NewDeclCache(s.buildCache != nil),
 		}
 	}
 
@@ -1178,7 +1178,8 @@ func (s *Session) CompilePackage(srcs *sources.Sources, tContext *types.Context)
 
 	// Store the built package sources in the cache for future use.
 	// The sources should contain all cachable declarations at this point.
-	if s.buildCache != nil {
+	// Skip storing cache if the sources haven't changed since read from cache.
+	if s.buildCache != nil && srcs.Changed() {
 		s.buildCache.Store(srcs, srcs.ImportPath, time.Now())
 	}
 

compiler/declCache.go

@@ -3,49 +3,100 @@ package compiler
 import (
 	"encoding/gob"
 	"fmt"
+	"sort"
 )
 
 type DeclCache struct {
 	enabled bool
 	decls   map[string]*Decl
+	changed bool
 }
 
 func init() {
+	// Register any types that are referenced by an interface so that
+	// the gob encoder/decoder can handle them.
 	gob.Register(&DeclCache{})
 }
 
-func NewDeclCache(enable bool) *DeclCache {
-	return &DeclCache{
-		enabled: enable,
-		decls:   map[string]*Decl{},
-	}
+func NewDeclCache(enabled bool) *DeclCache {
+	return &DeclCache{enabled: enabled}
 }
 
 func (dc *DeclCache) GetDecl(fullname string) *Decl {
+	if dc == nil || !dc.enabled {
+		return nil // cache is disabled
+	}
 	return dc.decls[fullname]
 }
 
 func (dc *DeclCache) PutDecl(decl *Decl) {
-	if !dc.enabled {
-		// If not enabled, do nothing since the cache is not being stored.
-		return
+	if dc == nil || !dc.enabled {
+		return // cache is disabled
 	}
 
+	if dc.decls == nil {
+		dc.decls = map[string]*Decl{}
+	}
 	if existing, ok := dc.decls[decl.FullName]; ok {
 		if existing != decl {
 			panic(fmt.Errorf(`decl cache conflict: different decls with same name: %q`, decl.FullName))
 		}
 		return
 	}
 	dc.decls[decl.FullName] = decl
+	dc.changed = true
+}
+
+func (dc *DeclCache) Changed() bool {
+	return dc != nil && dc.changed
 }
 
 func (dc *DeclCache) Read(decode func(any) error) error {
-	// TODO: Implement decl cache serialization.
+	if dc == nil || !dc.enabled {
+		return nil // cache is disabled
+	}
+
+	var count int
+	if err := decode(&count); err != nil {
+		return err
+	}
+
+	if dc.decls == nil {
+		dc.decls = map[string]*Decl{}
+	}
+	for i := 0; i < count; i++ {
+		decl := &Decl{}
+		if err := decode(decl); err != nil {
+			return err
+		}
+		fmt.Printf("Read decl from cache: %s\n", decl.FullName) // TODO(grantnelson-wf): REMOVE
+		dc.decls[decl.FullName] = decl
+	}
+
 	return nil
 }
 
 func (dc *DeclCache) Write(encode func(any) error) error {
-	// TODO: Implement decl cache serialization.
+	if dc == nil || !dc.enabled {
+		return nil // cache is disabled
+	}
+
+	count := len(dc.decls)
+	if err := encode(count); err != nil {
+		return err
+	}
+
+	names := make([]string, 0, count)
+	for name := range dc.decls {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	for _, name := range names {
+		fmt.Printf("Wrote decl to cache: %s\n", name) // TODO(grantnelson-wf): REMOVE
+		if err := encode(dc.decls[name]); err != nil {
+			return err
+		}
+	}
 	return nil
 }

compiler/package.go

@@ -119,11 +119,7 @@ type funcContext struct {
 }
 
 func newRootCtx(tContext *types.Context, srcs *sources.Sources, minify bool) *funcContext {
-	declCache, ok := srcs.CacheData.(*DeclCache)
-	if !ok {
-		declCache = NewDeclCache(false)
-	}
-
+	declCache, _ := srcs.DeclCache.(*DeclCache)
 	funcCtx := &funcContext{
 		FuncInfo: srcs.TypeInfo.InitFuncInfo,
 		pkgCtx: &pkgContext{

compiler/sources/serializer.go

@@ -3,11 +3,37 @@ package sources
 import (
 	"bytes"
 	"encoding/gob"
+	"errors"
 	"go/ast"
 	"go/token"
 	"sync"
+
+	"github.com/gopherjs/gopherjs/build/cache"
 )
 
+// DeclCache represents additional data, a collection of precompiled
+// declarations, to be cached along with the sources.
+//
+// The interface is used to prevent circular dependencies between packages.
+type DeclCache interface {
+	cache.Cacheable
+
+	// Changed indicates whether the cache data has changed since it was loaded.
+	Changed() bool
+}
+
+// Changed indicates whether the sources was loaded from the cache and
+// if it has been modified since then.
+// The cache will not check this automatically, so that the sources can be
+// stored even if it hasn't changed.
+// This should check this before calling cache.Store to avoid unnecessary work.
+//
+// This does not include changes to the type information or other information
+// that is not part of the cached data.
+func (s *Sources) Changed() bool {
+	return s != nil && (!s.loadedFromCache || s.DeclCache.Changed())
+}
+
 func (s *Sources) GobEncode() ([]byte, error) {
 	buf := &bytes.Buffer{}
 	err := s.Write(gob.NewEncoder(buf).Encode)
@@ -51,7 +77,10 @@ func (s *Sources) Write(encode func(any) error) error {
 	if err := encode(s.JSFiles); err != nil {
 		return err
 	}
-	if err := s.CacheData.Write(encode); err != nil {
+	if s.DeclCache == nil {
+		return errors.New(`may not write the sources' DeclCache with a nil DeclCache`)
+	}
+	if err := s.DeclCache.Write(encode); err != nil {
 		return err
 	}
 	return nil
@@ -87,7 +116,14 @@ func (s *Sources) Read(decode func(any) error) error {
 	if err := decode(&s.JSFiles); err != nil {
 		return err
 	}
-	return s.CacheData.Read(decode)
+	if s.DeclCache == nil {
+		return errors.New(`may not read the sources' DeclCache with a nil DeclCache`)
+	}
+	if err := s.DeclCache.Read(decode); err != nil {
+		return err
+	}
+	s.loadedFromCache = true
+	return nil
 }
 
 // prepareFile is run when serializing a source to remove fields that can be

compiler/sources/serializer_test.go

@@ -45,7 +45,7 @@ func TestRoundTrip(t *testing.T) {
 		Files:      pkgs.Syntax,
 		FileSet:    pkgs.Fset,
 		JSFiles:    jsFiles,
-		CacheData:  &cacheDataStub{},
+		DeclCache:  &cacheDataStub{},
 	}
 
 	// Serialize sources
@@ -56,7 +56,7 @@ func TestRoundTrip(t *testing.T) {
 
 	// Deserialize sources
 	srcs1 := &Sources{
-		CacheData: &cacheDataStub{},
+		DeclCache: &cacheDataStub{},
 	}
 	if err := srcs1.Read(gob.NewDecoder(buf).Decode); err != nil {
 		t.Fatalf("failed to deserialize sources: %v", err)
@@ -130,6 +130,10 @@ func checkSourcesAreEqual(t *testing.T, orig, other *Sources) {
 
 type cacheDataStub struct{}
 
+func (t *cacheDataStub) Changed() bool {
+	return false
+}
+
 func (t *cacheDataStub) Write(encode func(any) error) error {
 	return nil
 }

compiler/sources/sources.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/neelance/astrewrite"
 
-	"github.com/gopherjs/gopherjs/build/cache"
 	"github.com/gopherjs/gopherjs/compiler/incjs"
 	"github.com/gopherjs/gopherjs/compiler/internal/analysis"
 	"github.com/gopherjs/gopherjs/compiler/internal/typeparams"
@@ -59,16 +58,13 @@ type Sources struct {
 	// This is nil until set by ParseGoLinknames.
 	GoLinknames []linkname.GoLinkname
 
-	// CacheData is a object that holds any additional cacheable data
-	// for these sources. This must be set to a non-nil instances of the
-	// additional cache prior to encoding/decoding.
-	//
-	// Mainly this is used to store precompiled declarations,
-	// see [compiler/declCache.go].
-	//
-	// Warning: Make sure that any data stored here has had its types
-	// registered with the gob package for Gob encoding/decoding.
-	CacheData cache.Cacheable
+	// loadedFromCache indicates whether the sources were loaded from cache.
+	loadedFromCache bool
+
+	// DeclCache is a object that holds any additional cacheable data,
+	// such as precompiled declarations, for these sources.
+	// See [compiler/declCache.go].
+	DeclCache DeclCache
 }
 
 type Importer func(path, srcDir string) (*Sources, error)