gopherjs · nevkontakte · Apr 17, 2024 · Dec 2, 2023 · Dec 2, 2023 · Dec 17, 2023
diff --git a/build/build_test.go b/build/build_test.go
@@ -418,18 +418,17 @@ func TestOverlayAugmentation(t *testing.T) {
 				test.want = test.src
 			}
 
-			fsetSrc := token.NewFileSet()
-			fileSrc := srctesting.Parse(t, fsetSrc, pkgName+test.src)
+			f := srctesting.New(t)
+			fileSrc := f.Parse("test.go", pkgName+test.src)
 
 			overrides := map[string]overrideInfo{}
 			augmentOverlayFile(fileSrc, overrides)
 			pruneImports(fileSrc)
 
-			got := srctesting.Format(t, fsetSrc, fileSrc)
+			got := srctesting.Format(t, f.FileSet, fileSrc)
 
-			fsetWant := token.NewFileSet()
-			fileWant := srctesting.Parse(t, fsetWant, pkgName+test.want)
-			want := srctesting.Format(t, fsetWant, fileWant)
+			fileWant := f.Parse("test.go", pkgName+test.want)
+			want := srctesting.Format(t, f.FileSet, fileWant)
 
 			if got != want {
 				t.Errorf("augmentOverlayFile and pruneImports got unexpected code:\n"+
@@ -720,18 +719,17 @@ func TestOriginalAugmentation(t *testing.T) {
 		t.Run(test.desc, func(t *testing.T) {
 			pkgName := "package testpackage\n\n"
 			importPath := `math/rand`
-			fsetSrc := token.NewFileSet()
-			fileSrc := srctesting.Parse(t, fsetSrc, pkgName+test.src)
+			f := srctesting.New(t)
+			fileSrc := f.Parse("test.go", pkgName+test.src)
 
 			augmentOriginalImports(importPath, fileSrc)
 			augmentOriginalFile(fileSrc, test.info)
 			pruneImports(fileSrc)
 
-			got := srctesting.Format(t, fsetSrc, fileSrc)
+			got := srctesting.Format(t, f.FileSet, fileSrc)
 
-			fsetWant := token.NewFileSet()
-			fileWant := srctesting.Parse(t, fsetWant, pkgName+test.want)
-			want := srctesting.Format(t, fsetWant, fileWant)
+			fileWant := f.Parse("test.go", pkgName+test.want)
+			want := srctesting.Format(t, f.FileSet, fileWant)
 
 			if got != want {
 				t.Errorf("augmentOriginalImports, augmentOriginalFile, and pruneImports got unexpected code:\n"+

diff --git a/build/cache/cache.go b/build/cache/cache.go
@@ -58,7 +58,7 @@ func Clear() error {
 // the cache. For example, any artifacts that were cached for a minified build
 // must not be reused for a non-minified build. GopherJS version change also
 // invalidates the cache. It is callers responsibility to ensure that artifacts
-// passed the the StoreArchive function were generated with the same build
+// passed the StoreArchive function were generated with the same build
 // parameters as the cache is configured.
 //
 // There is no upper limit for the total cache size. It can be cleared

diff --git a/circle.yml b/circle.yml
@@ -74,6 +74,8 @@ orbs:
 jobs:
   build:
     executor: gopherjs
+    environment:
+      GOPHERJS_EXPERIMENT: generics
     steps:
     - setup_and_install_gopherjs
     - run:
@@ -129,6 +131,8 @@ jobs:
   gopherjs_tests:
     executor: gopherjs
     parallelism: 4
+    environment:
+      GOPHERJS_EXPERIMENT: generics
     steps:
     - setup_and_install_gopherjs
     - run:
@@ -155,6 +159,8 @@ jobs:
 
   gorepo_tests:
     executor: gopherjs
+    environment:
+      GOPHERJS_EXPERIMENT: generics
     parallelism: 4
     steps:
     - setup_environment
@@ -170,6 +176,8 @@ jobs:
     executor:
       name: win/default
       shell: powershell.exe
+    environment:
+      GOPHERJS_EXPERIMENT: generics
     steps:
       - checkout
       - run:
@@ -204,6 +212,8 @@ jobs:
   darwin_smoke:
     macos:
       xcode: 13.4.1 # Mac OS 12.6.1, see https://circleci.com/docs/using-macos/
+    environment:
+      GOPHERJS_EXPERIMENT: generics
     steps:
       - checkout
       - setup_environment

diff --git a/compiler/analysis/info.go b/compiler/analysis/info.go
@@ -342,8 +342,8 @@ func (fi *FuncInfo) visitCallExpr(n *ast.CallExpr) ast.Visitor {
 		return nil // No need to walk under this CallExpr, we already did it manually.
 	default:
 		if astutil.IsTypeExpr(f, fi.pkgInfo.Info) {
-			// This is a type assertion, not a call. Type assertion itself is not
-			// blocking, but we will visit the expression itself.
+			// This is a type conversion, not a call. Type assertion itself is not
+			// blocking, but we will visit the input expression.
 		} else {
 			// The function is returned by a non-trivial expression. We have to be
 			// conservative and assume that function might be blocking.
@@ -357,6 +357,7 @@ func (fi *FuncInfo) visitCallExpr(n *ast.CallExpr) ast.Visitor {
 func (fi *FuncInfo) callToNamedFunc(callee types.Object) {
 	switch o := callee.(type) {
 	case *types.Func:
+		o = o.Origin()
 		if recv := o.Type().(*types.Signature).Recv(); recv != nil {
 			if _, ok := recv.Type().Underlying().(*types.Interface); ok {
 				// Conservatively assume that an interface implementation may be blocking.

diff --git a/compiler/analysis/info_test.go b/compiler/analysis/info_test.go
@@ -2,7 +2,6 @@ package analysis
 
 import (
 	"go/ast"
-	"go/token"
 	"go/types"
 	"testing"
 
@@ -34,11 +33,11 @@ func notBlocking() {
 	func() { println() } ()
 }
 `
-	fset := token.NewFileSet()
-	file := srctesting.Parse(t, fset, src)
-	typesInfo, typesPkg := srctesting.Check(t, fset, file)
+	f := srctesting.New(t)
+	file := f.Parse("test.go", src)
+	typesInfo, typesPkg := f.Check("pkg/test", file)
 
-	pkgInfo := AnalyzePkg([]*ast.File{file}, fset, typesInfo, typesPkg, func(f *types.Func) bool {
+	pkgInfo := AnalyzePkg([]*ast.File{file}, f.FileSet, typesInfo, typesPkg, func(f *types.Func) bool {
 		panic("isBlocking() should be never called for imported functions in this test.")
 	})
 

diff --git a/compiler/astutil/astutil.go b/compiler/astutil/astutil.go
@@ -35,7 +35,15 @@ func NewIdent(name string, t types.Type, info *types.Info, pkg *types.Package) *
 	return ident
 }
 
+// IsTypeExpr returns true if expr denotes a type. This can be used to
+// distinguish between calls and type conversions.
 func IsTypeExpr(expr ast.Expr, info *types.Info) bool {
+	// Note that we could've used info.Types[expr].IsType() instead of doing our
+	// own analysis. However, that creates a problem because we synthesize some
+	// *ast.CallExpr nodes and, more importantly, *ast.Ident nodes that denote a
+	// type. Unfortunately, because the flag that controls
+	// types.TypeAndValue.IsType() return value is unexported we wouldn't be able
+	// to set it correctly. Thus, we can't rely on IsType().
 	switch e := expr.(type) {
 	case *ast.ArrayType, *ast.ChanType, *ast.FuncType, *ast.InterfaceType, *ast.MapType, *ast.StructType:
 		return true
@@ -47,6 +55,20 @@ func IsTypeExpr(expr ast.Expr, info *types.Info) bool {
 	case *ast.SelectorExpr:
 		_, ok := info.Uses[e.Sel].(*types.TypeName)
 		return ok
+	case *ast.IndexExpr:
+		ident, ok := e.X.(*ast.Ident)
+		if !ok {
+			return false
+		}
+		_, ok = info.Uses[ident].(*types.TypeName)
+		return ok
+	case *ast.IndexListExpr:
+		ident, ok := e.X.(*ast.Ident)
+		if !ok {
+			return false
+		}
+		_, ok = info.Uses[ident].(*types.TypeName)
+		return ok
 	case *ast.ParenExpr:
 		return IsTypeExpr(e.X, info)
 	default:

diff --git a/compiler/astutil/astutil_test.go b/compiler/astutil/astutil_test.go
@@ -2,7 +2,6 @@ package astutil
 
 import (
 	"go/ast"
-	"go/token"
 	"strconv"
 	"testing"
 
@@ -44,8 +43,7 @@ func TestImportsUnsafe(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.desc, func(t *testing.T) {
 			src := "package testpackage\n\n" + test.imports
-			fset := token.NewFileSet()
-			file := srctesting.Parse(t, fset, src)
+			file := srctesting.New(t).Parse("test.go", src)
 			got := ImportsUnsafe(file)
 			if got != test.want {
 				t.Fatalf("ImportsUnsafe() returned %t, want %t", got, test.want)
@@ -81,8 +79,7 @@ func TestImportName(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.desc, func(t *testing.T) {
 			src := "package testpackage\n\n" + test.src
-			fset := token.NewFileSet()
-			file := srctesting.Parse(t, fset, src)
+			file := srctesting.New(t).Parse("test.go", src)
 			if len(file.Imports) != 1 {
 				t.Fatal(`expected one and only one import`)
 			}
@@ -399,8 +396,7 @@ func TestHasDirectiveOnFile(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.desc, func(t *testing.T) {
 			const action = `do-stuff`
-			fset := token.NewFileSet()
-			file := srctesting.Parse(t, fset, test.src)
+			file := srctesting.New(t).Parse("test.go", test.src)
 			if got := hasDirective(file, action); got != test.want {
 				t.Errorf(`hasDirective(%T, %q) returned %t, want %t`, file, action, got, test.want)
 			}

diff --git a/compiler/compiler.go b/compiler/compiler.go
@@ -17,6 +17,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/gopherjs/gopherjs/compiler/internal/symbol"
 	"github.com/gopherjs/gopherjs/compiler/prelude"
 	"golang.org/x/tools/go/gcexportdata"
 )
@@ -32,22 +33,6 @@ func init() {
 	}
 }
 
-type ErrorList []error
-
-func (err ErrorList) Error() string {
-	if len(err) == 0 {
-		return "<no errors>"
-	}
-	return fmt.Sprintf("%s (and %d more errors)", err[0].Error(), len(err[1:]))
-}
-
-func (err ErrorList) Normalize() error {
-	if len(err) == 0 {
-		return nil
-	}
-	return err
-}
-
 // Archive contains intermediate build outputs of a single package.
 //
 // This is a logical equivalent of an object file in traditional compilers.
@@ -112,9 +97,13 @@ type Decl struct {
 	// Go compiler/linker toolchain. Used by GopherJS to support go:linkname
 	// directives. Must be set for decls that are supported by go:linkname
 	// implementation.
-	LinkingName SymName
+	LinkingName symbol.Name
 	// A list of package-level JavaScript variable names this symbol needs to declare.
 	Vars []string
+	// A JS expression by which the object represented by this decl may be
+	// referenced within the package context. Empty if the decl represents no such
+	// object.
+	RefExpr string
 	// NamedRecvType is method named recv declare.
 	NamedRecvType string
 	// JavaScript code that declares basic information about a symbol. For a type
@@ -326,7 +315,7 @@ func WritePkgCode(pkg *Archive, dceSelection map[*Decl]struct{}, gls goLinknameS
 			if recv, method, ok := d.LinkingName.IsMethod(); ok {
 				code = fmt.Sprintf("\t$linknames[%q] = $unsafeMethodToFunction(%v,%q,%t);\n", d.LinkingName.String(), d.NamedRecvType, method, strings.HasPrefix(recv, "*"))
 			} else {
-				code = fmt.Sprintf("\t$linknames[%q] = %s;\n", d.LinkingName.String(), d.Vars[0])
+				code = fmt.Sprintf("\t$linknames[%q] = %s;\n", d.LinkingName.String(), d.RefExpr)
 			}
 			if _, err := w.Write(removeWhitespace([]byte(code), minify)); err != nil {
 				return err
@@ -357,7 +346,7 @@ func WritePkgCode(pkg *Archive, dceSelection map[*Decl]struct{}, gls goLinknameS
 			if !found {
 				continue // The symbol is not affected by a go:linkname directive.
 			}
-			lines = append(lines, fmt.Sprintf("\t\t%s = $linknames[%q];\n", d.Vars[0], impl.String()))
+			lines = append(lines, fmt.Sprintf("\t\t%s = $linknames[%q];\n", d.RefExpr, impl.String()))
 		}
 		if len(lines) > 0 {
 			code := fmt.Sprintf("\t$pkg.$initLinknames = function() {\n%s};\n", strings.Join(lines, ""))

diff --git a/compiler/errors.go b/compiler/errors.go
@@ -0,0 +1,68 @@
+package compiler
+
+import (
+	"errors"
+	"fmt"
+)
+
+// ErrTooManyErrors is added to the ErrorList by the Trim method.
+var ErrTooManyErrors = errors.New("too many errors")
+
+// ErrorList wraps multiple errors as a single error.
+type ErrorList []error
+
+func (errs ErrorList) Error() string {
+	if len(errs) == 0 {
+		return "<no errors>"
+	}
+	return fmt.Sprintf("%s (and %d more errors)", errs[0].Error(), len(errs[1:]))
+}
+
+// ErrOrNil returns nil if ErrorList is empty, or the error otherwise.
+func (errs ErrorList) ErrOrNil() error {
+	if len(errs) == 0 {
+		return nil
+	}
+	return errs
+}
+
+// Append an error to the list.
+//
+// If err is an instance of ErrorList, the lists are concatenated together,
+// otherwise err is appended at the end of the list. If err is nil, the list is
+// returned unmodified.
+//
+//	err := DoStuff()
+//	errList := errList.Append(err)
+func (errs ErrorList) Append(err error) ErrorList {
+	if err == nil {
+		return errs
+	}
+	if err, ok := err.(ErrorList); ok {
+		return append(errs, err...)
+	}
+	return append(errs, err)
+}
+
+// AppendDistinct is similar to Append, but doesn't append the error if it has
+// the same message as the last error on the list.
+func (errs ErrorList) AppendDistinct(err error) ErrorList {
+	if l := len(errs); l > 0 {
+		if prev := errs[l-1]; prev != nil && err.Error() == prev.Error() {
+			return errs // The new error is the same as the last one, skip it.
+		}
+	}
+
+	return errs.Append(err)
+}
+
+// Trim the error list if it has more than limit errors. If the list is trimmed,
+// all extraneous errors are replaced with a single ErrTooManyErrors, making the
+// returned ErrorList length of limit+1.
+func (errs ErrorList) Trim(limit int) ErrorList {
+	if len(errs) <= limit {
+		return errs
+	}
+
+	return append(errs[:limit], ErrTooManyErrors)
+}