gopherjs · grantnelson-wf · Jan 12, 2026 · Mar 4, 2024 · Mar 5, 2024 · Mar 12, 2024
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -15,7 +15,7 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  GO_VERSION: 1.19.13
+  GO_VERSION: 1.20.14
   NODE_VERSION: 18
   GOLANGCI_VERSION: v1.53.3
   SOURCE_MAP_SUPPORT: true

diff --git a/.github/workflows/measure-size.yml b/.github/workflows/measure-size.yml
@@ -3,7 +3,7 @@ name: Measure canonical app size
 on: ['pull_request']
 
 env:
-  GO_VERSION: '~1.19.13'
+  GO_VERSION: '~1.20.14'
 
 jobs:
   measure:

diff --git a/README.md b/README.md
@@ -33,21 +33,21 @@ Nearly everything, including Goroutines ([compatibility documentation](https://g
 
 ### Installation and Usage
 
-GopherJS [requires Go 1.19 or newer](https://github.com/gopherjs/gopherjs/blob/master/doc/compatibility.md#go-version-compatibility). If you need an older Go
+GopherJS [requires Go 1.20 or newer](https://github.com/gopherjs/gopherjs/blob/master/doc/compatibility.md#go-version-compatibility). If you need an older Go
 version, you can use an [older GopherJS release](https://github.com/gopherjs/gopherjs/releases).
 
 Install GopherJS with `go install`:
 
 ```
-go install github.com/gopherjs/gopherjs@v1.19.0-beta2  # Or replace 'v1.19.0-beta2' with another version.
+go install github.com/gopherjs/gopherjs@v1.20.0-beta1  # Or replace 'v1.20.0-beta1' with another version.
 ```
 
-If your local Go distribution as reported by `go version` is newer than Go 1.19, then you need to set the `GOPHERJS_GOROOT` environment variable to a directory that contains a Go 1.19 distribution. For example:
+If your local Go distribution as reported by `go version` is newer than Go 1.20, then you need to set the `GOPHERJS_GOROOT` environment variable to a directory that contains a Go 1.20 distribution. For example:
 
 ```
-go install golang.org/dl/go1.19.13@latest
-go1.19.13 download
-export GOPHERJS_GOROOT="$(go1.19.13 env GOROOT)"  # Also add this line to your .profile or equivalent.
+go install golang.org/dl/go1.20.14@latest
+go1.20.14 download
+export GOPHERJS_GOROOT="$(go1.20.14 env GOROOT)"  # Also add this line to your .profile or equivalent.
 ```
 
 Now you can use `gopherjs build [package]`, `gopherjs build [files]` or `gopherjs install [package]` which behave similar to the `go` tool. For `main` packages, these commands create a `.js` file and `.js.map` source map in the current directory or in `$GOPATH/bin`. The generated JavaScript file can be used as usual in a website. Use `gopherjs help [command]` to get a list of possible command line flags, e.g. for minification and automatically watching for changes.

diff --git a/build/build.go b/build/build.go
@@ -725,19 +725,33 @@ func (p *PackageData) XTestPackage() *PackageData {
 
 // InstallPath returns the path where "gopherjs install" command should place the
 // generated output.
-func (p *PackageData) InstallPath() string {
+func (p *PackageData) InstallPath() (string, error) {
 	if p.IsCommand() {
 		name := filepath.Base(p.ImportPath) + ".js"
+
 		// For executable packages, mimic go tool behavior if possible.
 		if gobin := os.Getenv("GOBIN"); gobin != "" {
-			return filepath.Join(gobin, name)
-		} else if gopath := os.Getenv("GOPATH"); gopath != "" {
-			return filepath.Join(gopath, "bin", name)
-		} else if home, err := os.UserHomeDir(); err == nil {
-			return filepath.Join(home, "go", "bin", name)
+			return filepath.Join(gobin, name), nil
+		}
+
+		if gopath := os.Getenv("GOPATH"); gopath != "" {
+			return filepath.Join(gopath, "bin", name), nil
+		}
+
+		if home, err := os.UserHomeDir(); err == nil {
+			return filepath.Join(home, "go", "bin", name), nil
 		}
 	}
-	return p.PkgObj
+
+	if p.PkgObj != "" {
+		return p.PkgObj, nil
+	}
+
+	// The build.Context.Import method stopped populating build.Package.PkgObj
+	// in 1.20 for packages found in the Goroot. Currently we don't use the
+	// build.Package.PkgObj except for a fallback when no other locations
+	// can be found for command packages to install.
+	return "", fmt.Errorf(`no install location available for %q`, p.ImportPath)
 }
 
 // Session manages internal state GopherJS requires to perform a build.

diff --git a/build/context.go b/build/context.go
@@ -368,11 +368,18 @@ func (cc chainedCtx) Import(importPath string, srcDir string, mode build.ImportM
 	pkg, err := cc.primary.Import(importPath, srcDir, mode)
 	if err == nil {
 		return pkg, nil
-	} else if IsPkgNotFound(err) {
-		return cc.secondary.Import(importPath, srcDir, mode)
-	} else {
-		return nil, err
 	}
+
+	if IsPkgNotFound(err) {
+		if pkg, err2 := cc.secondary.Import(importPath, srcDir, mode); err2 == nil {
+			return pkg, nil
+		}
+		// if err2 != nil, return the original error that occurred in primary
+		// context since the secondary is for the virtual gopherjs context,
+		// meaning err2 will say that GOPATH is not set which is misleading.
+	}
+
+	return nil, err
 }
 
 func (cc chainedCtx) Env() Env { return cc.primary.Env() }

diff --git a/build/context_test.go b/build/context_test.go
@@ -1,7 +1,6 @@
 package build
 
 import (
-	"fmt"
 	"go/build"
 	"net/http"
 	"path/filepath"
@@ -31,16 +30,19 @@ func TestSimpleCtx(t *testing.T) {
 
 	t.Run("exists", func(t *testing.T) {
 		tests := []struct {
+			name     string
 			buildCtx XContext
 			wantPkg  *PackageData
 		}{
 			{
+				name:     `embeddedCtx`,
 				buildCtx: ec,
 				wantPkg: &PackageData{
 					Package:   expectedPackage(&ec.bctx, "github.com/gopherjs/gopherjs/js", "wasm"),
 					IsVirtual: true,
 				},
 			}, {
+				name:     `goCtx`,
 				buildCtx: gc,
 				wantPkg: &PackageData{
 					Package:   expectedPackage(&gc.bctx, "fmt", "wasm"),
@@ -50,7 +52,7 @@ func TestSimpleCtx(t *testing.T) {
 		}
 
 		for _, test := range tests {
-			t.Run(fmt.Sprintf("%T", test.buildCtx), func(t *testing.T) {
+			t.Run(test.name, func(t *testing.T) {
 				importPath := test.wantPkg.ImportPath
 				got, err := test.buildCtx.Import(importPath, "", build.FindOnly)
 				if err != nil {
@@ -65,25 +67,27 @@ func TestSimpleCtx(t *testing.T) {
 
 	t.Run("not found", func(t *testing.T) {
 		tests := []struct {
+			name       string
 			buildCtx   XContext
 			importPath string
 		}{
 			{
+				name:       `embeddedCtx`,
 				buildCtx:   ec,
 				importPath: "package/not/found",
 			}, {
-				// Outside of the main module.
+				name:       `goCtx outside of the main module`,
 				buildCtx:   gc,
 				importPath: "package/not/found",
 			}, {
-				// In the main module.
+				name:       `goCtx in the main module`,
 				buildCtx:   gc,
 				importPath: "github.com/gopherjs/gopherjs/not/found",
 			},
 		}
 
 		for _, test := range tests {
-			t.Run(fmt.Sprintf("%T", test.buildCtx), func(t *testing.T) {
+			t.Run(test.name, func(t *testing.T) {
 				_, err := ec.Import(test.importPath, "", build.FindOnly)
 				want := "cannot find package"
 				if err == nil || !strings.Contains(err.Error(), want) {
@@ -210,6 +214,6 @@ func expectedPackage(bctx *build.Context, importPath string, goarch string) *bui
 		PkgTargetRoot: targetRoot,
 		BinDir:        filepath.Join(bctx.GOROOT, "bin"),
 		Goroot:        true,
-		PkgObj:        filepath.Join(targetRoot, importPath+".a"),
+		PkgObj:        ``, // not populated for Goroot packages since 1.20
 	}
 }
diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -1071,6 +1071,9 @@ func (fc *funcContext) translateBuiltin(name string, sig *types.Signature, args
 	case "Offsetof":
 		sel, _ := fc.selectionOf(astutil.RemoveParens(args[0]).(*ast.SelectorExpr))
 		return fc.formatExpr("%d", typesutil.OffsetOf(sizes32, sel))
+	case "SliceData":
+		t := fc.typeOf(args[0]).Underlying().(*types.Slice)
+		return fc.formatExpr(`$sliceData(%e, %s)`, args[0], fc.typeName(t))
 	default:
 		panic(fmt.Sprintf("Unhandled builtin: %s\n", name))
 	}

diff --git a/compiler/linkname/linkname.go b/compiler/linkname/linkname.go
@@ -22,7 +22,84 @@ type GoLinkname struct {
 	Reference      symbol.Name
 }
 
-// ParseGoLinknames processed comments in a source file and extracts //go:linkname
+// readLinknameFromComment reads the given comment to determine if it's a go:linkname
+// directive then returns the linkname information, otherwise returns nil.
+func readLinknameFromComment(pkgPath string, comment *ast.Comment) (*GoLinkname, error) {
+	if !strings.HasPrefix(comment.Text, `//go:linkname `) {
+		return nil, nil // Not a linkname compiler directive.
+	}
+
+	fields := strings.Fields(comment.Text)
+
+	// Check that the directive comment has both parts and is on the line by itself.
+	switch len(fields) {
+	case 2:
+		// Ignore one-argument form //go:linkname localName
+		// This is typically used with "insert"-style links to
+		// suppresses the usual error for a function that lacks a body.
+		// The "insert"-style links aren't supported by GopherJS so
+		// these bodiless functions have to be overridden in the natives anyway.
+		return nil, nil
+	case 3:
+		// Continue for two-argument form //go:linkname localName importPath.extName
+		break
+	default:
+		return nil, fmt.Errorf(`gopherjs: usage requires 2 arguments: //go:linkname localName importPath.extName`)
+	}
+
+	localPkg, localName := pkgPath, fields[1]
+	extPkg, extName := ``, fields[2]
+
+	if localName == extName {
+		// Ignore self referencing links, //go:linkname localName localName
+		// These function similar to one-argument links.
+		return nil, nil
+	}
+
+	pathOffset := 0
+	if pos := strings.LastIndexByte(extName, '/'); pos != -1 {
+		pathOffset = pos + 1
+	}
+
+	if idx := strings.IndexByte(extName[pathOffset:], '.'); idx != -1 {
+		extPkg, extName = extName[:pathOffset+idx], extName[pathOffset+idx+1:]
+	}
+
+	return &GoLinkname{
+		Reference:      symbol.Name{PkgPath: localPkg, Name: localName},
+		Implementation: symbol.Name{PkgPath: extPkg, Name: extName},
+	}, nil
+}
+
+// isMitigatedVarLinkname checks if the given go:linkname directive on
+// a variable, which GopherJS doesn't support, is known about.
+// We silently ignore such directives, since it doesn't seem to cause any problems.
+func isMitigatedVarLinkname(sym symbol.Name) bool {
+	mitigatedLinks := map[string]bool{
+		`reflect.zeroVal`:         true,
+		`math/bits.overflowError`: true, // Defaults in bits_errors_bootstrap.go
+		`math/bits.divideError`:   true, // Defaults in bits_errors_bootstrap.go
+	}
+	return mitigatedLinks[sym.String()]
+}
+
+// isMitigatedInsertLinkname checks if the given go:linkname directive
+// on a function, where the function has a body, is known about.
+// These are unsupported "insert"-style go:linkname directives,
+// that we ignore as a link and handle case-by-case in native overrides.
+func isMitigatedInsertLinkname(sym symbol.Name) bool {
+	mitigatedPkg := map[string]bool{
+		`runtime`:       true, // Lots of "insert"-style links
+		`internal/fuzz`: true, // Defaults to no-op stubs
+	}
+	mitigatedLinks := map[string]bool{
+		`internal/bytealg.runtime_cmpstring`: true,
+		`os.net_newUnixFile`:                 true,
+	}
+	return mitigatedPkg[sym.PkgPath] || mitigatedLinks[sym.String()]
+}
+
+// parseGoLinknames processed comments in a source file and extracts //go:linkname
 // compiler directive from the comments.
 //
 // The following directive format is supported:
@@ -45,63 +122,38 @@ func ParseGoLinknames(fset *token.FileSet, pkgPath string, file *ast.File) ([]Go
 	isUnsafe := astutil.ImportsUnsafe(file)
 
 	processComment := func(comment *ast.Comment) error {
-		if !strings.HasPrefix(comment.Text, "//go:linkname ") {
-			return nil // Not a linkname compiler directive.
+		link, err := readLinknameFromComment(pkgPath, comment)
+		if err != nil || link == nil {
+			return err
 		}
 
-		// TODO(nevkontakte): Ideally we should check that the directive comment
-		// is on a line by itself, line Go compiler does, but ast.Comment doesn't
-		// provide an easy way to find that out.
-
 		if !isUnsafe {
 			return fmt.Errorf(`//go:linkname is only allowed in Go files that import "unsafe"`)
 		}
 
-		fields := strings.Fields(comment.Text)
-		if len(fields) != 3 {
-			return fmt.Errorf(`usage (all fields required): //go:linkname localname importpath.extname`)
-		}
-
-		localPkg, localName := pkgPath, fields[1]
-		extPkg, extName := "", fields[2]
-		if pos := strings.LastIndexByte(extName, '/'); pos != -1 {
-			if idx := strings.IndexByte(extName[pos+1:], '.'); idx != -1 {
-				extPkg, extName = extName[0:pos+idx+1], extName[pos+idx+2:]
-			}
-		} else if idx := strings.IndexByte(extName, '.'); idx != -1 {
-			extPkg, extName = extName[0:idx], extName[idx+1:]
-		}
-
+		localName := link.Reference.Name
 		node := lookupTopNode(file, localName)
 		if node == nil {
 			return fmt.Errorf("//go:linkname local symbol %q is not found in the current source file", localName)
 		}
 
 		decl, isFunc := node.(*ast.FuncDecl)
 		if !isFunc {
-			if pkgPath == "math/bits" || pkgPath == "reflect" {
-				// These standard library packages are known to use go:linkname with
-				// variables, which GopherJS doesn't support. We silently ignore such
-				// directives, since it doesn't seem to cause any problems.
+			if isMitigatedVarLinkname(link.Reference) {
 				return nil
 			}
 			return fmt.Errorf("gopherjs: //go:linkname is only supported for functions, got %T", node)
 		}
 
 		if decl.Body != nil {
-			if pkgPath == "runtime" || pkgPath == "internal/bytealg" || pkgPath == "internal/fuzz" {
-				// These standard library packages are known to use unsupported
-				// "insert"-style go:linkname directives, which we ignore here and handle
-				// case-by-case in native overrides.
+			if isMitigatedInsertLinkname(link.Reference) {
 				return nil
 			}
-			return fmt.Errorf("gopherjs: //go:linkname can not insert local implementation into an external package %q", extPkg)
+			return fmt.Errorf("gopherjs: //go:linkname can not insert local implementation into an external package %q", link.Implementation.PkgPath)
 		}
+
 		// Local function has no body, treat it as a reference to an external implementation.
-		directives = append(directives, GoLinkname{
-			Reference:      symbol.Name{PkgPath: localPkg, Name: localName},
-			Implementation: symbol.Name{PkgPath: extPkg, Name: extName},
-		})
+		directives = append(directives, *link)
 		return nil
 	}