Upgrade Playground to GopherJS 1.18.0-beta1

playground/README.md

@@ -13,3 +13,12 @@ gopherjs serve
 ```
 
 Then open <http://localhost:8080/github.com/gopherjs/gopherjs.github.io/playground>.
+
+## Upgrading GopherJS release
+
+```shell
+VERSION="$(go list -m -versions -f "{{ range .Versions }}{{ println . }}{{ end }}" github.com/gopherjs/gopherjs | tail -n 1)"
+echo "$VERSION"
+go get -v "github.com/gopherjs/gopherjs@$VERSION"
+go mod tidy
+```

playground/gen.go

@@ -1,3 +1,5 @@
-//go:generate ./update.sh
+//go:generate go run ./internal/cmd/precompile
+//go:generate go install github.com/gopherjs/gopherjs
+//go:generate gopherjs build -m .
 
 package main

playground/go.mod

@@ -3,14 +3,21 @@ module github.com/gopherjs/gopherjs.github.io/playground
 go 1.17
 
 require (
-	github.com/gopherjs/gopherjs v0.0.0-20211108205335-ed9a9b14a747
+	github.com/gopherjs/gopherjs v1.18.0-beta1
 	github.com/neelance/go-angularjs v0.0.0-20170205214111-8c6312cca6e2
-	golang.org/x/tools v0.1.7
+	github.com/sirupsen/logrus v1.8.1
+	golang.org/x/tools v0.1.12
 	honnef.co/go/js/dom v0.0.0-20210725211120-f030747120f2
 	honnef.co/go/js/xhr v0.0.0-20150307031022-00e3346113ae
 )
 
 require (
+	github.com/fsnotify/fsnotify v1.5.1 // indirect
 	github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86 // indirect
+	github.com/neelance/sourcemap v0.0.0-20200213170602-2833bce08e4c // indirect
+	github.com/shurcooL/httpfs v0.0.0-20190707220628-8d4bc4ba7749 // indirect
+	github.com/stretchr/testify v1.7.0 // indirect
+	golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f // indirect
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 	honnef.co/go/js/util v0.0.0-20150216223935-96b8dd9d1621 // indirect
 )

playground/internal/cmd/precompile/precompile.go

@@ -0,0 +1,132 @@
+// Program precompile updates pre-built standard library packages for the
+// playground.
+//
+// This script performs the following sequence of steps:
+//
+//  - Enumerate all standard packages that should be available in the playground.
+//  - Precompile them, including transitive dependencies.
+//  - Delete all old precompiled archive.
+//  - Write all new precompiled archive in their place.
+//
+// This will use the same GopherJS version as specified in the playground gm.mod
+// to ensure consistency. The script uses GopherJS compiler API directly, so
+// it doesn't require the GopherJS tool to be installed.
+package main
+
+import (
+	"flag"
+	"fmt"
+	gobuild "go/build"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/gopherjs/gopherjs/build"
+	"github.com/gopherjs/gopherjs/compiler"
+	log "github.com/sirupsen/logrus"
+)
+
+type logLevelFlag struct{ log.Level }
+
+func (l *logLevelFlag) Set(raw string) error { return l.UnmarshalText([]byte(raw)) }
+
+var (
+	logLevel logLevelFlag = logLevelFlag{Level: log.ErrorLevel}
+)
+
+func init() {
+	flag.Var(&logLevel, "log_level", "Default logging level.")
+}
+
+func run() error {
+	s, err := build.NewSession(&build.Options{
+		Verbose: true,
+		Minify:  true,
+		NoCache: true,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to create a build session: %w", err)
+	}
+
+	packages, err := s.XContext().Match([]string{"std"})
+	if err != nil {
+		return fmt.Errorf("failed to enumerate standard library packages")
+	}
+	packages = importable(packages)
+	packages = append(packages, "github.com/gopherjs/gopherjs/js", "github.com/gopherjs/gopherjs/nosync")
+
+	for _, pkg := range packages {
+		_, err := s.BuildImportPath(pkg)
+		if err != nil {
+			return fmt.Errorf("failed to precompile package %q: %w", pkg, err)
+		}
+	}
+
+	target, err := targetDir(s)
+	if err := os.RemoveAll(target); err != nil {
+		return fmt.Errorf("failed to clean out old precompiled archives: %w", err)
+	}
+
+	for _, archive := range s.UpToDateArchives {
+		if err := writeArchive(target, archive); err != nil {
+			return fmt.Errorf("failed to write package %q archive: %w", archive.ImportPath, err)
+		}
+	}
+
+	return nil
+}
+
+func writeArchive(target string, archive *compiler.Archive) error {
+	path := filepath.Join(target, filepath.FromSlash(archive.ImportPath)+".a.js")
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return fmt.Errorf("failed to create precompiled package directory %q: %w", filepath.Dir(path), err)
+	}
+	f, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("failed to create precompiled archive %q: %w", path, err)
+	}
+	defer f.Close()
+
+	return compiler.WriteArchive(archive, f)
+}
+
+// targetDir returns path to the directory where precompiled packages must be
+// stored.
+func targetDir(s *build.Session) (string, error) {
+	pkg, err := s.XContext().Import("github.com/gopherjs/gopherjs.github.io/playground", "", gobuild.FindOnly)
+	if err != nil {
+		return "", fmt.Errorf("failed to find playground package directory: %w", err)
+	}
+	target := filepath.Join(pkg.Dir, "pkg")
+	if _, err := os.Stat(target); os.IsNotExist(err) {
+		return "", fmt.Errorf("target directory %q not found", target)
+	}
+	return target, nil
+}
+
+// importable excludes packages that are incompatible with GopherJS or can't be
+// directly imported by the user code. The remaining packages will be used as a
+// starting points for precompilation.
+func importable(all []string) []string {
+	result := []string{}
+	for _, pkg := range all {
+		switch {
+		case strings.HasPrefix(pkg, "vendor/"),
+			strings.Contains(pkg, "internal"),
+			strings.Contains(pkg, "pprof"),
+			strings.Contains(pkg, "plugin"):
+			continue
+		default:
+			result = append(result, pkg)
+		}
+	}
+	return result
+}
+
+func main() {
+	flag.Parse()
+	log.SetLevel(logLevel.Level)
+	if err := run(); err != nil {
+		log.Fatalf("Precompilation failed: %v", err)
+	}
+}

playground/playground.go

@@ -174,13 +174,19 @@ func main() {
 						}
 
 						data := js.Global.Get("Uint8Array").New(req.Response).Interface().([]byte)
-						packages[path], err = compiler.ReadArchive(path+".a", path, bytes.NewReader(data), importContext.Packages)
+						packages[path], err = compiler.ReadArchive(path+".a", bytes.NewReader(data))
 						if err != nil {
 							scope.Apply(func() {
 								scope.Set("output", []Line{Line{"type": "err", "content": err.Error()}})
 							})
 							return
 						}
+						if err := packages[path].RegisterTypes(importContext.Packages); err != nil {
+							scope.Apply(func() {
+								scope.Set("output", []Line{Line{"type": "err", "content": err.Error()}})
+							})
+							return
+						}
 						pkgsReceived++
 						if pkgsReceived == len(pkgsToLoad) {
 							run(loadOnly)