trying json encoding

Author: grantnelson-wf

build/build.go

@@ -807,13 +807,12 @@ func NewSession(options *Options) (*Session, error) {
 	// Disable caching by leaving buildCache set to nil.
 	if !s.options.NoCache {
 		s.buildCache = &cache.BuildCache{
-			GOOS:          env.GOOS,
-			GOARCH:        env.GOARCH,
-			GOROOT:        env.GOROOT,
-			GOPATH:        env.GOPATH,
-			BuildTags:     append([]string{}, env.BuildTags...),
-			TestedPackage: options.TestedPackage,
-			Version:       compiler.Version,
+			GOOS:      env.GOOS,
+			GOARCH:    env.GOARCH,
+			GOROOT:    env.GOROOT,
+			GOPATH:    env.GOPATH,
+			BuildTags: append([]string{}, env.BuildTags...),
+			Version:   compiler.Version,
 		}
 	}
 
@@ -1224,8 +1223,7 @@ func (s *Session) CompilePackage(srcs *sources.Sources, tContext *types.Context)
 		if dc != nil && dc.Changed() {
 			s.buildCache.Store(dc, srcs.ImportPath, time.Now())
 		}
-		// Uncomment to get statics for individual packages cache usage.
-		// log.Infof(`DeclCache stats: %s`, dc.String())
+		log.Debugf(`DeclCache stats: %s`, dc.String())
 	}
 
 	s.UpToDateArchives[srcs.ImportPath] = archive

build/cache/cache.go

@@ -6,6 +6,7 @@ import (
 	"compress/gzip"
 	"crypto/sha256"
 	"encoding/gob"
+	"encoding/json"
 	"fmt"
 	"go/build"
 	"io"
@@ -20,9 +21,10 @@ import (
 // Cacheable defines methods to serialize and deserialize cachable objects.
 // This object should represent a package's build artifact.
 //
-// The encode and decode functions are typically wrappers around gob.Encoder.Encode
-// and gob.Decoder.Decode, but other formats are possible as well, the same way
-// as FileSet.Write and FileSet.Read work with any encode/decode functions.
+// The encode and decode functions are typically wrappers around gob or json
+// Encoder.Encode and Decoder.Decode, but other formats are possible as well,
+// the same way as FileSet.Write and FileSet.Read work with any encode/decode
+// functions.
 type Cacheable interface {
 	Write(encode func(any) error) error
 	Read(decode func(any) error) error
@@ -113,31 +115,18 @@ type BuildCache struct {
 
 	// Version should be set to compiler.Version
 	Version string
-
-	// TestedPackage is the import path of the package being tested, or
-	// empty when not building for tests. The package under test is built
-	// with *_test.go sources included so we should always skip reading
-	// and writing cache in that case.
-	TestedPackage string
 }
 
+const encoding = `json`
+
 func (bc BuildCache) String() string {
 	return fmt.Sprintf("%#v", bc)
 }
 
-func (bc *BuildCache) isTestPackage(importPath string) bool {
-	return bc != nil && len(importPath) > 0 &&
-		(importPath == bc.TestedPackage || importPath == bc.TestedPackage+"_test")
-}
-
 func (bc *BuildCache) Store(c Cacheable, importPath string, buildTime time.Time) bool {
 	if bc == nil {
 		return false // Caching is disabled.
 	}
-	if bc.isTestPackage(importPath) {
-		log.Infof("Skipped storing cache of test package for %q.", importPath)
-		return false // Don't use cache when building the package under test.
-	}
 
 	start := time.Now()
 	path := cachedPath(bc.packageKey(importPath))
@@ -169,14 +158,32 @@ func (bc *BuildCache) Store(c Cacheable, importPath string, buildTime time.Time)
 	return true
 }
 
+func (bc *BuildCache) getEncode(w io.Writer) func(any) error {
+	switch encoding {
+	case `gob`:
+		return gob.NewEncoder(w).Encode
+	case `json`:
+		return json.NewEncoder(w).Encode
+	default:
+		panic(fmt.Errorf(`unexpected encoding for encoder: %q`, encoding))
+	}
+}
+
+func (bc *BuildCache) getDecode(r io.Reader) func(any) error {
+	switch encoding {
+	case `gob`:
+		return gob.NewDecoder(r).Decode
+	case `json`:
+		return json.NewDecoder(r).Decode
+	default:
+		panic(fmt.Errorf(`unexpected encoding for decoder: %q`, encoding))
+	}
+}
+
 func (bc *BuildCache) Load(c Cacheable, importPath string, srcModTime time.Time) bool {
 	if bc == nil {
 		return false // Caching is disabled.
 	}
-	if bc.isTestPackage(importPath) {
-		log.Infof("Skipped loading cache of test package for %q.", importPath)
-		return false // Don't use cache when building the package under test.
-	}
 
 	start := time.Now()
 	path := cachedPath(bc.packageKey(importPath))
@@ -213,11 +220,11 @@ func (bc *BuildCache) serialize(c Cacheable, buildTime time.Time, w io.Writer) (
 		}
 	}()
 
-	ge := gob.NewEncoder(zw)
-	if err := ge.Encode(buildTime); err != nil {
+	encode := bc.getEncode(w)
+	if err := encode(buildTime); err != nil {
 		return err
 	}
-	return c.Write(ge.Encode)
+	return c.Write(encode)
 }
 
 func (bc *BuildCache) deserialize(c Cacheable, srcModTime time.Time, r io.Reader) (buildTime time.Time, old bool, err error) {
@@ -232,14 +239,14 @@ func (bc *BuildCache) deserialize(c Cacheable, srcModTime time.Time, r io.Reader
 		}
 	}()
 
-	gd := gob.NewDecoder(zr)
-	if err := gd.Decode(&buildTime); err != nil {
+	decode := bc.getDecode(r)
+	if err := decode(&buildTime); err != nil {
 		return buildTime, false, err
 	}
 	if srcModTime.After(buildTime) {
 		return buildTime, true, nil // Package is out-of-date, cache miss.
 	}
-	return buildTime, false, c.Read(gd.Decode)
+	return buildTime, false, c.Read(decode)
 }
 
 // commonKey returns a part of the cache key common for all artifacts generated

build/cache/cache_test.go

@@ -114,47 +114,6 @@ func TestOldCache(t *testing.T) {
 	}
 }
 
-func TestSkipOfTestPackage(t *testing.T) {
-	cacheForTest(t)
-
-	const data = `fake/data`
-	const importPath = "fake/package"
-	want := &CacheableMock{Data: data}
-	srcModTime := newTime(0.0)
-	buildTime := newTime(5.0)
-
-	bc := BuildCache{}
-	if !bc.Store(want, importPath, buildTime) {
-		t.Errorf("Failed to store %s with %q.", importPath, want.Data)
-	}
-
-	// Simulate writing a cache for a pacakge under test.
-	bc.TestedPackage = importPath
-	if bc.Store(want, importPath, buildTime) {
-		t.Errorf("Got: cache stored for %q. Want: test packages to not write to cache.", importPath)
-	}
-	if bc.Store(want, importPath+"_test", buildTime) {
-		t.Errorf("Got: cache stored for %q. Want: test packages to not write to cache.", importPath+"_test")
-	}
-
-	// Simulate reading the cache for a pacakge under test.
-	got := &CacheableMock{}
-	if bc.Load(got, importPath, srcModTime) {
-		t.Errorf("Got: cache with %q. Want: test package cache to not be loaded for %q.", got.Data, importPath)
-	}
-	got = &CacheableMock{}
-	if bc.Load(got, importPath+"_test", srcModTime) {
-		t.Errorf("Got: cache with %q. Want: test package cache to not be loaded for %q.", got.Data, importPath+"_test")
-	}
-
-	// No package under test, cache should work normally and load previously stored non-test package.
-	bc.TestedPackage = ""
-	got = &CacheableMock{}
-	if !bc.Load(got, importPath, srcModTime) || got.Data != want.Data {
-		t.Errorf("Got: cache with %q. Want: up-to-date package cache to be loaded with %q.", got.Data, want.Data)
-	}
-}
-
 func cacheForTest(t *testing.T) {
 	t.Helper()
 	originalRoot := cacheRoot

compiler/declCache.go

@@ -91,12 +91,12 @@ func (dc *DeclCache) SetDecls(importedPaths []string, importDecls, typeDecls, va
 }
 
 type serializableDeclCache struct {
-	ImportPath    string
-	ImportedPaths []string
-	ImportDecls   []*Decl
-	TypeDecls     []*Decl
-	VarDecls      []*Decl
-	FuncDecls     []*Decl
+	ImportPath    string   `json:"path"`
+	ImportedPaths []string `json:"p,omitempty"`
+	ImportDecls   []*Decl  `json:"i,omitempty"`
+	TypeDecls     []*Decl  `json:"t,omitempty"`
+	VarDecls      []*Decl  `json:"v,omitempty"`
+	FuncDecls     []*Decl  `json:"f,omitempty"`
 }
 
 func (dc *DeclCache) Read(decode func(any) error) error {

compiler/decls.go

@@ -37,50 +37,48 @@ type Decl struct {
 	// implementation.
 	LinkingName symbol.Name
 	// A list of package-level JavaScript variable names this symbol needs to declare.
-	Vars []string
+	Vars []string `json:",omitempty"`
 	// A JS expression by which the object represented by this decl may be
 	// referenced within the package context. Empty if the decl represents no such
 	// object.
-	RefExpr string
+	RefExpr string `json:",omitempty"`
 	// NamedRecvType is method named recv declare.
-	NamedRecvType string
+	NamedRecvType string `json:",omitempty"`
 	// JavaScript code that declares a local variable for an imported package.
-	ImportCode []byte
+	ImportCode []byte `json:",omitempty"`
 	// JavaScript code that declares basic information about a named type symbol.
 	// It configures basic information about the type and its identity.
-	TypeDeclCode []byte
+	TypeDeclCode []byte `json:",omitempty"`
 	// JavaScript code that assigns exposed named types to the package.
-	ExportTypeCode []byte
+	ExportTypeCode []byte `json:",omitempty"`
 	// JavaScript code that declares basic information about an anonymous type.
 	// It configures basic information about the type.
 	// This is added to the finish setup phase to have access to all packages.
-	AnonTypeDeclCode []byte
+	AnonTypeDeclCode []byte `json:",omitempty"`
 	// JavaScript code that declares basic information about a function or
 	// method symbol. This contains the function's or method's compiled body.
 	// This is added to the finish setup phase to have access to all packages.
-	FuncDeclCode []byte
+	FuncDeclCode []byte `json:",omitempty"`
 	// JavaScript code that assigns exposed functions to the package.
 	// This is added to the finish setup phase to have access to all packages.
-	ExportFuncCode []byte
+	ExportFuncCode []byte `json:",omitempty"`
 	// JavaScript code that initializes reflection metadata about a type's method list.
 	// This is added to the finish setup phase to have access to all packages.
-	MethodListCode []byte
+	MethodListCode []byte `json:",omitempty"`
 	// JavaScript code that initializes the rest of reflection metadata about a type
 	// (e.g. struct fields, array type sizes, element types, etc.).
 	// This is added to the finish setup phase to have access to all packages.
-	TypeInitCode []byte
+	TypeInitCode []byte `json:",omitempty"`
 	// JavaScript code that needs to be executed during the package init phase to
 	// set the symbol up (e.g. initialize package-level variable value).
-	InitCode []byte
+	InitCode []byte `json:",omitempty"`
 	// DCEInfo stores the information for dead-code elimination.
 	DCEInfo dce.Info
 	// Set to true if a function performs a blocking operation (I/O or
 	// synchronization). The compiler will have to generate function code such
 	// that it can be resumed after a blocking operation completes without
 	// blocking the main thread in the meantime.
 	Blocking bool
-	// ForGeneric inidicates this decl is for a generic function or type.
-	ForGeneric bool
 }
 
 // minify returns a copy of Decl with unnecessary whitespace removed from the
@@ -185,10 +183,9 @@ func (fc *funcContext) importDecls() (importedPaths []string, importDecls []*Dec
 
 // newImportDecl registers the imported package and returns a Decl instance for it.
 func (fc *funcContext) newImportDecl(importedPkg *types.Package) *Decl {
-	fullName := importDeclFullName(importedPkg)
 	pkgVar := fc.importedPkgVar(importedPkg)
 	d := &Decl{
-		FullName:   fullName,
+		FullName:   importDeclFullName(importedPkg),
 		Vars:       []string{pkgVar},
 		ImportCode: []byte(fmt.Sprintf("\t%s = $packages[\"%s\"];\n", pkgVar, importedPkg.Path())),
 		InitCode:   fc.CatchOutput(1, func() { fc.translateStmt(fc.importInitializer(importedPkg.Path()), nil) }),
@@ -253,9 +250,8 @@ func (fc *funcContext) varDecls(vars []*types.Var) []*Decl {
 // newVarDecl creates a new Decl describing a variable, given an explicit
 // initializer.
 func (fc *funcContext) newVarDecl(init *types.Initializer) *Decl {
-	fullName := varDeclFullName(init)
 	d := &Decl{
-		FullName: fullName,
+		FullName: varDeclFullName(init),
 	}
 	assignLHS := []ast.Expr{}
 	for _, o := range init.Lhs {
@@ -371,9 +367,8 @@ func (fc *funcContext) newFuncVarDecl(fun *ast.FuncDecl, o *types.Func, instance
 	}
 
 	varDecl := &Decl{
-		FullName:   fullName,
-		Vars:       []string{varName},
-		ForGeneric: generic,
+		FullName: fullName,
+		Vars:     []string{varName},
 	}
 	varDecl.Dce().SetName(o, nil, nil)
 
@@ -386,23 +381,20 @@ func (fc *funcContext) newFuncVarDecl(fun *ast.FuncDecl, o *types.Func, instance
 }
 
 func (fc *funcContext) newCallMainFuncDecl(mainFunc *types.Func) *Decl {
-	fullName := mainFuncDeclFullName()
 	d := &Decl{
-		FullName: fullName,
+		FullName: mainFuncDeclFullName(),
 		InitCode: fc.CatchOutput(1, func() { fc.translateStmt(fc.callMainFunc(mainFunc), nil) }),
 	}
 	return d
 }
 
 // newFuncDecl returns a Decl that defines a package-level function or a method.
 func (fc *funcContext) newFuncDecl(fun *ast.FuncDecl, inst typeparams.Instance) *Decl {
-	fullName := funcDeclFullName(inst)
 	o := fc.pkgCtx.Defs[fun.Name].(*types.Func)
 	d := &Decl{
-		FullName:    fullName,
+		FullName:    funcDeclFullName(inst),
 		Blocking:    fc.pkgCtx.IsBlocking(inst),
 		LinkingName: symbol.New(o),
-		ForGeneric:  !inst.IsTrivial(),
 	}
 	d.Dce().SetName(o, inst.TNest, inst.TArgs)
 
@@ -531,17 +523,15 @@ func (fc *funcContext) namedTypeDecls(typeNames typesutil.TypeNames) ([]*Decl, e
 // of the type, keyed by the type argument combination. Otherwise it contains
 // the type definition directly.
 func (fc *funcContext) newNamedTypeVarDecl(obj *types.TypeName) *Decl {
-	fullName := typeVarDeclFullName(obj)
 	name := fc.objectName(obj)
 	generic := fc.pkgCtx.instanceSet.Pkg(obj.Pkg()).ObjHasInstances(obj)
 	varName := name
 	if generic {
 		varName += ` = []`
 	}
 	varDecl := &Decl{
-		FullName:   fullName,
-		Vars:       []string{varName},
-		ForGeneric: generic,
+		FullName: typeVarDeclFullName(obj),
+		Vars:     []string{varName},
 	}
 	varDecl.Dce().SetName(obj, nil, nil)
 	if isPkgLevel(obj) {
@@ -555,7 +545,6 @@ func (fc *funcContext) newNamedTypeVarDecl(obj *types.TypeName) *Decl {
 // newNamedTypeInstDecl returns a Decl that represents an instantiation of a
 // named Go type.
 func (fc *funcContext) newNamedTypeInstDecl(inst typeparams.Instance) (*Decl, error) {
-	fullName := typeDeclFullName(inst)
 	originType := inst.Object.Type().(*types.Named)
 
 	fc.typeResolver = typeparams.NewResolver(fc.pkgCtx.typesCtx, inst)
@@ -575,8 +564,7 @@ func (fc *funcContext) newNamedTypeInstDecl(inst typeparams.Instance) (*Decl, er
 
 	underlying := instanceType.Underlying()
 	d := &Decl{
-		FullName:   fullName,
-		ForGeneric: !inst.IsTrivial(),
+		FullName: typeDeclFullName(inst),
 	}
 	d.Dce().SetName(inst.Object, inst.TNest, inst.TArgs)
 	fc.pkgCtx.CollectDCEDeps(d, func() {
@@ -700,9 +688,8 @@ func (fc *funcContext) anonTypeDecls(anonTypes []*types.TypeName) []*Decl {
 	}
 	decls := []*Decl{}
 	for _, t := range anonTypes {
-		fullName := anonTypeDeclFullName(t)
 		d := &Decl{
-			FullName: fullName,
+			FullName: anonTypeDeclFullName(t),
 			Vars:     []string{t.Name()},
 		}
 		d.Dce().SetName(t, nil, nil)