gopherjs · nevkontakte · Mar 2, 2024 · Dec 2, 2023 · Dec 2, 2023 · Dec 17, 2023
diff --git a/compiler/analysis/info.go b/compiler/analysis/info.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/gopherjs/gopherjs/compiler/astutil"
 	"github.com/gopherjs/gopherjs/compiler/typesutil"
+	"golang.org/x/exp/typeparams"
 )
 
 type continueStmt struct {
@@ -342,8 +343,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 +358,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 = typeparams.OriginMethod(o) // TODO(nevkontakte): Can be replaced with o.Origin() in Go 1.19.
 		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/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/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"
 )
@@ -112,9 +113,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 +331,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 +362,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, ""))