trying json encoding

Author: grantnelson-wf

build/cache/cache.go

@@ -6,7 +6,6 @@ import (
 	"compress/gzip"
 	"crypto/sha256"
 	"encoding/gob"
-	"encoding/json"
 	"fmt"
 	"go/build"
 	"io"
@@ -21,10 +20,9 @@ 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 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.
+// 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.
 type Cacheable interface {
 	Write(encode func(any) error) error
 	Read(decode func(any) error) error
@@ -115,18 +113,33 @@ type BuildCache struct {
 
 	// Version should be set to compiler.Version
 	Version string
-}
 
-const encoding = `json`
+	// 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. Since we are caching prior to
+	// type-checking for generics, any package importing the package under
+	// test should be unaffected.
+	TestedPackage string
+}
 
 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))
@@ -158,32 +171,14 @@ 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))
@@ -220,11 +215,11 @@ func (bc *BuildCache) serialize(c Cacheable, buildTime time.Time, w io.Writer) (
 		}
 	}()
 
-	encode := bc.getEncode(w)
-	if err := encode(buildTime); err != nil {
+	ge := gob.NewEncoder(zw)
+	if err := ge.Encode(buildTime); err != nil {
 		return err
 	}
-	return c.Write(encode)
+	return c.Write(ge.Encode)
 }
 
 func (bc *BuildCache) deserialize(c Cacheable, srcModTime time.Time, r io.Reader) (buildTime time.Time, old bool, err error) {
@@ -239,14 +234,14 @@ func (bc *BuildCache) deserialize(c Cacheable, srcModTime time.Time, r io.Reader
 		}
 	}()
 
-	decode := bc.getDecode(r)
-	if err := decode(&buildTime); err != nil {
+	gd := gob.NewDecoder(zr)
+	if err := gd.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(decode)
+	return buildTime, false, c.Read(gd.Decode)
 }
 
 // commonKey returns a part of the cache key common for all artifacts generated

compiler/decls.go

@@ -4,6 +4,8 @@ package compiler
 // such as imports, types, functions, etc.
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"go/ast"
 	"go/constant"
@@ -101,6 +103,16 @@ func (d *Decl) Dce() *dce.Info {
 	return &d.DCEInfo
 }
 
+func (d *Decl) GobEncode() ([]byte, error) {
+	buf := &bytes.Buffer{}
+	err := json.NewEncoder(buf).Encode(d) // Use JSON for encoding
+	return buf.Bytes(), err
+}
+
+func (d *Decl) GobDecode(data []byte) error {
+	return json.NewDecoder(bytes.NewReader(data)).Decode(d) // Use JSDON for encoding
+}
+
 // topLevelObjects extracts package-level variables, functions and named types
 // from the package AST.
 func (fc *funcContext) topLevelObjects(srcs *sources.Sources) (vars []*types.Var, functions []*ast.FuncDecl, typeNames typesutil.TypeNames) {