Fixed the duplicate compiler issue

Author: grantnelson-wf

playground/compile.js

@@ -164,33 +164,40 @@ func (r *compilerImp) collectAllSources(root *sources.Sources) (map[string]*sour
 	allSources := map[string]*sources.Sources{
 		root.ImportPath: root,
 	}
+	if err := r.addSourcesToSourcesMap(allSources, root); err != nil {
+		return nil, err
+	}
+
+	// Ensure `runtime` is added even if it was not explicitly imported.
+	if err := r.addPathToSourcesMap(allSources, `runtime`); err != nil {
+		return nil, err
+	}
+	return allSources, nil
+}
 
-	var collectDeps func(srcs *sources.Sources) error
-	collectDeps = func(srcs *sources.Sources) error {
-		for _, path := range srcs.UnresolvedImports() {
-			if _, has := allSources[path]; has {
-				continue // Already collected.
-			}
-
-			// Run load synchronously to await for the package to be available.
-			srcs, _, err := r.cache.Load(path)
-			if err != nil {
-				// Failed to load an import.
-				return fmt.Errorf(`failed to load package %q: %w`, path, err)
-			}
-			allSources[srcs.ImportPath] = srcs
-
-			if err := collectDeps(srcs); err != nil {
-				return err
-			}
+func (r *compilerImp) addSourcesToSourcesMap(allSources map[string]*sources.Sources, srcs *sources.Sources) error {
+	for _, path := range srcs.UnresolvedImports() {
+		if err := r.addPathToSourcesMap(allSources, path); err != nil {
+			return err
 		}
-		return nil
 	}
-	if err := collectDeps(root); err != nil {
-		return nil, err
+	return nil
+}
+
+func (r *compilerImp) addPathToSourcesMap(allSources map[string]*sources.Sources, path string) error {
+	if _, has := allSources[path]; has {
+		return nil // Already collected.
 	}
 
-	return allSources, nil
+	// Run load synchronously to await for the package to be available.
+	srcs, _, err := r.cache.Load(path)
+	if err != nil {
+		// Failed to load an import.
+		return fmt.Errorf(`failed to load package %q: %w`, path, err)
+	}
+
+	allSources[srcs.ImportPath] = srcs
+	return r.addSourcesToSourcesMap(allSources, srcs)
 }
 
 func (r *compilerImp) prepareAndCompilePackages(rootPath string, allSources map[string]*sources.Sources) ([]*compiler.Archive, error) {

playground/internal/cmd/compile/internal/compiler.go

@@ -35,28 +35,35 @@ func newPackageCache(fetcher Fetcher) *packageCache {
 // This will block until the sources are available.
 // If the sources are cached, then this will be fast,
 // otherwise it will await a network request before returning.
+//
+// Since GET http requests do not deduplicate requests for the same
+// package file and we could get duplicate requests because of diamond
+// dependencies (more than one package imports the same package),
+// this load will deduplicate requests. Multiple requests to the same
+// import path will create only one network request but will block
+// all the `Load` calls for that import path until the package has been loaded.
 func (pc *packageCache) Load(importPath string) (*sources.Sources, loadResult, error) {
-	load := pc.getLoadStratagy(importPath)
+	load := pc.getLoadStrategy(importPath)
 
 	srcs := &sources.Sources{}
 	result, err := load(srcs)
 	return srcs, result, err
 }
 
-// loadStrategy is the stratagy for performing the load based
+// loadStrategy is the strategy for performing the load based
 // on the current state of any other load of the same package.
 //
 // If this returns loadFailed, the error will be non-nil.
 // and if the error is non-nil, the loadResult will be loadFailed.
 type loadStrategy func(srcs *sources.Sources) (loadResult, error)
 
-// getLoadStratagy returns the stratagy to complete loading the package.
-// When the returned stratagy is run, it may either return the cached
+// getLoadStrategy returns the strategy to complete loading the package.
+// When the returned strategy is run, it may either return the cached
 // package immediately, wait for an in-progress load to complete,
 // or perform the load itself.
 //
-// getLoadStratagy will not block, but the returned function may block.
-func (pc *packageCache) getLoadStratagy(importPath string) loadStrategy {
+// getLoadStrategy will not block, but the returned function may block.
+func (pc *packageCache) getLoadStrategy(importPath string) loadStrategy {
 	pc.lock.Lock()
 	defer pc.lock.Unlock()
 
@@ -75,7 +82,7 @@ func (pc *packageCache) getLoadStratagy(importPath string) loadStrategy {
 	return pc.startLoading(importPath, ch)
 }
 
-// alreadyLoaded returns a load stratagy that returns the cached sources.
+// alreadyLoaded returns a load strategy that returns the cached sources.
 // The given cached sources must be the sources that are already loaded in the cache.
 func (pc *packageCache) alreadyLoaded(cached *sources.Sources) loadStrategy {
 	return func(srcs *sources.Sources) (loadResult, error) {
@@ -84,7 +91,7 @@ func (pc *packageCache) alreadyLoaded(cached *sources.Sources) loadStrategy {
 	}
 }
 
-// alreadyInprogress returns a load stratagy that waits for an in-progress load to complete.
+// alreadyInprogress returns a load strategy that waits for an in-progress load to complete.
 // The given channel will be waited on until it is closed, indicating the load is complete
 // and the sources should now be in the cache.
 func (pc *packageCache) alreadyInprogress(importPath string, ch chan struct{}) loadStrategy {
@@ -105,26 +112,25 @@ func (pc *packageCache) alreadyInprogress(importPath string, ch chan struct{}) l
 	}
 }
 
-// startLoading returns a load stratagy that performs the package load via a network request.
+// startLoading returns a load strategy that performs the package load via a network request.
 // This occurs when the package is not cached and not currently in progress.
 // The given channel will be closed when the load is complete to indicate to any
 // other processed waiting on the load that it is done.
 func (pc *packageCache) startLoading(importPath string, ch chan struct{}) loadStrategy {
 	return func(srcs *sources.Sources) (loadResult, error) {
 		fetched, err := pc.fetcher.FetchPackage(importPath)
-		if err != nil {
-			delete(pc.inprogress, importPath)
-			close(ch)
-			return loadFailed, err
-		}
 
 		pc.lock.Lock()
 		defer pc.lock.Unlock()
+		defer close(ch)
+		defer delete(pc.inprogress, importPath)
+
+		if err != nil {
+			return loadFailed, err
+		}
 
 		pc.cached[importPath] = fetched
 		*srcs = *fetched // Shallow copy the fetched sources into passed in sources.
-		delete(pc.inprogress, importPath)
-		close(ch)
 		return loadFetched, nil
 	}
 }

playground/internal/cmd/compile/internal/packageCache.go

@@ -2,6 +2,7 @@ package page
 
 import (
 	"go/format"
+	"sync"
 
 	"github.com/gopherjs/gopherjs.github.io/playground/internal/bindings/react"
 	"github.com/gopherjs/gopherjs.github.io/playground/internal/bindings/url"
@@ -14,15 +15,39 @@ func Playground() *react.Element {
 	return react.CreateElement(playgroundComponent, nil)
 }
 
+// Since React can create Refs twice when in "Strict Mode" but we do not
+// want any of these resources created twice so they are singletons.
+var (
+	compiler     = OnceValue(workers.NewCompiler)
+	runner       = OnceValue(workers.NewRunner)
+	snippetStore = OnceValue(snippets.NewStore)
+)
+
+// TODO(grantnelson-wf): Remove when we've reached go1.21
+func OnceValue[T any](f func() T) func() T {
+	var (
+		once   sync.Once
+		result T
+	)
+	return func() T {
+		once.Do(func() {
+			temp := f
+			f = nil
+			result = temp()
+		})
+		return result
+	}
+}
+
 func playgroundComponent(props react.Props) *react.Element {
 	var (
 		bannerRef  = react.UseRefLazy(NoopBannerHandle)
 		outputRef  = react.UseRefLazy(NoopOutput)
 		codeBoxRef = react.UseRefLazy(NoopCodeBoxHandle)
 
-		compilerRef      = react.UseRefLazy(workers.NewCompiler)
-		runnerRef        = react.UseRefLazy(workers.NewRunner)
-		snippetsStoreRef = react.UseRefLazy(snippets.NewStore)
+		compilerRef      = react.UseRefLazy(compiler)
+		runnerRef        = react.UseRefLazy(runner)
+		snippetsStoreRef = react.UseRefLazy(snippetStore)
 	)
 
 	// Get version number from compiler webworker.