cleanup after tests

Author: grantnelson-wf

build/build.go

@@ -937,8 +937,6 @@ func (s *Session) BuildProject(pkg *PackageData) (*compiler.Archive, error) {
 	// ensure that runtime for gopherjs is imported
 	pkg.Imports = append(pkg.Imports, `runtime`)
 
-	//start := time.Now() // TODO(grantnelson-wf): REMOVE
-
 	// Load the project to get the sources for the parsed packages.
 	var rootSrcs *sources.Sources
 	var err error
@@ -951,13 +949,8 @@ func (s *Session) BuildProject(pkg *PackageData) (*compiler.Archive, error) {
 		return nil, err
 	}
 
-	//fmt.Println(`load Packages:`, time.Since(start)) // TODO(grantnelson-wf): REMOVE
-
 	// Compile the project into Archives containing the generated JS.
-	a, err := s.PrepareAndCompilePackages(rootSrcs)
-
-	//fmt.Println(`build project:`, time.Since(start)) // TODO(grantnelson-wf): REMOVE
-	return a, err
+	return s.PrepareAndCompilePackages(rootSrcs)
 }
 
 // GetSortedSources returns the sources sorted by import path.
@@ -1183,28 +1176,20 @@ func (s *Session) PrepareAndCompilePackages(rootSrcs *sources.Sources) (*compile
 	tContext := types.NewContext()
 	allSources := s.GetSortedSources()
 
-	//start := time.Now() // TODO(grantnelson-wf): REMOVE
-
 	// Prepare and analyze the source code.
 	// This will be performed recursively for all dependencies.
 	if err := compiler.PrepareAllSources(allSources, s.SourcesForImport, tContext); err != nil {
 		return nil, err
 	}
 
-	//fmt.Println(`prepared sources:`, time.Since(start)) // TODO(grantnelson-wf): REMOVE
-	//start = time.Now()
-
 	// Compile all the sources into archives.
 	for _, srcs := range allSources {
 		if _, err := s.CompilePackage(srcs, tContext); err != nil {
 			return nil, err
 		}
 	}
 
-	//fmt.Println(`compile packages:`, time.Since(start)) // TODO(grantnelson-wf): REMOVE
-
-	log.Infof(`DeclCache stats: %s`, compiler.GlobalDeclCacheStats()) // TODO(grantnelson-wf): Uncomment
-	//fmt.Println(`DeclCache stats:`, compiler.GlobalDeclCacheStats())// TODO(grantnelson-wf): REMOVE
+	log.Infof(`DeclCache stats: %s`, compiler.GlobalDeclCacheStats())
 
 	rootArchive, ok := s.UpToDateArchives[rootSrcs.ImportPath]
 	if !ok {

build/cache/cache.go

@@ -15,7 +15,6 @@ import (
 	"path/filepath"
 	"time"
 
-	"github.com/gopherjs/gopherjs/build/cache/pack"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -28,8 +27,6 @@ import (
 type Cacheable interface {
 	Write(encode func(any) error) error
 	Read(decode func(any) error) error
-	pack.Packable
-	pack.Unpackable
 }
 
 // Cache defines methods to store and load cacheable objects.
@@ -219,22 +216,21 @@ func (bc *BuildCache) Load(c Cacheable, importPath string, srcModTime time.Time)
 	return true
 }
 
-var encoding = `pack`
+// encoding is the encoding to use when serializing and deserializing the cache.
+// Possible values are seen in `getSerializer` and `getDeserializer`.
+// Using zip provides a CRC check for the data and reduces the file size but it is slightly slower.
+var encoding = `json`
 
 type serializeHandle func(c Cacheable, buildTime time.Time, w io.Writer) (err error)
 type deserializeHandle func(c Cacheable, srcModTime time.Time, r io.Reader) (buildTime time.Time, old bool, err error)
 
 func (bc *BuildCache) getSerializer() serializeHandle {
 	switch encoding {
-	case `pack`:
-		return bc.packSerialize
 	case `json`:
 		return bc.jsonSerialize
 	case `gob`:
 		return bc.gobSerialize
-	case `zipPack`:
-		return zipGobSerialize(bc.packSerialize)
-	case `zipJaon`:
+	case `zipJson`:
 		return zipGobSerialize(bc.jsonSerialize)
 	case `zipGob`:
 		return zipGobSerialize(bc.gobSerialize)
@@ -245,14 +241,10 @@ func (bc *BuildCache) getSerializer() serializeHandle {
 
 func (bc *BuildCache) getDeserializer() deserializeHandle {
 	switch encoding {
-	case `pack`:
-		return bc.packDeserialize
 	case `json`:
 		return bc.jsonDeserialize
 	case `gob`:
 		return bc.gobDeserialize
-	case `zipPack`:
-		return zipGobDeserialize(bc.packDeserialize)
 	case `zipJson`:
 		return zipGobDeserialize(bc.jsonDeserialize)
 	case `zipGob`:
@@ -329,25 +321,6 @@ func (bc *BuildCache) jsonDeserialize(c Cacheable, srcModTime time.Time, r io.Re
 	return buildTime, false, c.Read(decode)
 }
 
-func (bc *BuildCache) packSerialize(c Cacheable, buildTime time.Time, w io.Writer) (err error) {
-	e := pack.NewEncoder(w)
-	if err = e.EncodeTime(buildTime); err != nil {
-		return err
-	}
-	return c.PackEncode(e)
-}
-
-func (bc *BuildCache) packDeserialize(c Cacheable, srcModTime time.Time, r io.Reader) (buildTime time.Time, old bool, err error) {
-	d := pack.NewDecoder(r)
-	if err := d.DecodeTime(&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.PackDecode(d)
-}
-
 // commonKey returns a part of the cache key common for all artifacts generated
 // under a given BuildCache configuration.
 func (bc *BuildCache) commonKey() string {

build/cache/cache_test.go

@@ -5,15 +5,12 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-	"github.com/gopherjs/gopherjs/build/cache/pack"
 )
 
 type CacheableMock struct{ Data string }
 
 func (m *CacheableMock) Write(encode func(any) error) error { return encode(m.Data) }
 func (m *CacheableMock) Read(decode func(any) error) error  { return decode(&m.Data) }
-func (m *CacheableMock) PackEncode(e *pack.Encoder) error   { return e.EncodeString(m.Data) }
-func (m *CacheableMock) PackDecode(d *pack.Decoder) error   { return d.DecodeString(&m.Data) }
 
 func TestStore(t *testing.T) {
 	cacheForTest(t)