From 707213ed638396bead060fa5b83d25c3b4868c5f Mon Sep 17 00:00:00 2001
From: Nevkontakte <aleks@nevkontakte.com>
Date: Sun, 19 Feb 2023 17:49:36 +0000
Subject: [PATCH 1/5] Factor out unimplemented function translation.

(based on commit 7866b1ed6c9d0e7428f6caf7c5ab03eba9a6d345)
---
 compiler/functions.go | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/compiler/functions.go b/compiler/functions.go
index ed3062c60..ba4dea86b 100644
--- a/compiler/functions.go
+++ b/compiler/functions.go
@@ -75,7 +75,7 @@ func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl, inst typepar
 	// and assigns it to the JS expression defined by lvalue.
 	primaryFunction := func(lvalue string) []byte {
 		if fun.Body == nil {
-			return []byte(fmt.Sprintf("\t%s = function() {\n\t\t$throwRuntimeError(\"native function not implemented: %s\");\n\t};\n", lvalue, o.FullName()))
+			return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fc.unimplementedFunction(o)))
 		}
 
 		var recv *ast.Ident
@@ -162,7 +162,7 @@ func (fc *funcContext) translateStandaloneFunction(fun *ast.FuncDecl, inst typep
 	lvalue := fc.instName(inst)
 
 	if fun.Body == nil {
-		return []byte(fmt.Sprintf("\t%s = function() {\n\t\t$throwRuntimeError(\"native function not implemented: %s\");\n\t};\n", lvalue, o.FullName()))
+		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fc.unimplementedFunction(o)))
 	}
 
 	body := fc.nestedFunctionContext(info, sig, inst).translateFunctionBody(fun.Type, nil, fun.Body, lvalue)
@@ -174,6 +174,15 @@ func (fc *funcContext) translateStandaloneFunction(fun *ast.FuncDecl, inst typep
 	return code.Bytes()
 }
 
+// unimplementedFunction returns a JS function expression for a Go function
+// without a body, which would throw an exception if called.
+//
+// In Go such functions are either used with a //go:linkname directive or with
+// assembler intrinsics, only former of which is supported by GopherJS.
+func (fc *funcContext) unimplementedFunction(o *types.Func) string {
+	return fmt.Sprintf("function() {\n\t\t$throwRuntimeError(\"native function not implemented: %s\");\n\t}", o.FullName())
+}
+
 // translateFunctionBody translates body of a top-level or literal function.
 //
 // It returns a JS function expression that represents the given Go function.

From 0ee97fe943de7116192cabd9d4ce053ffe66e3c2 Mon Sep 17 00:00:00 2001
From: Nevkontakte <aleks@nevkontakte.com>
Date: Sat, 11 Mar 2023 19:56:01 +0000
Subject: [PATCH 2/5] Remove a special case for methods with array-pointer
 receivers.

(based on commit d15130fefba8693c948c7d3daffb005880609833)

This special case doesn't seem to serve any purpose that I can discern.
My best guess is that it was necessary at some point, but the compiler
has changed to not need it anymore.

The compiler seems to wrap the returned value in a pointer-type at a
call site as appropriate anyway and defining this method on the value
type doesn't seem correct.
---
 compiler/functions.go | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/compiler/functions.go b/compiler/functions.go
index ba4dea86b..54d857719 100644
--- a/compiler/functions.go
+++ b/compiler/functions.go
@@ -121,15 +121,7 @@ func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl, inst typepar
 		return code.Bytes()
 	}
 
-	if ptr, isPointer := sig.Recv().Type().(*types.Pointer); isPointer {
-		if _, isArray := ptr.Elem().Underlying().(*types.Array); isArray {
-			// Pointer-to-array is another special case.
-			// TODO(nevkontakte) Find out and document why.
-			code.Write(primaryFunction(prototypeVar))
-			code.Write(proxyFunction(ptrPrototypeVar, fmt.Sprintf("(new %s(this.$get()))", recvInstName)))
-			return code.Bytes()
-		}
-
+	if _, isPointer := sig.Recv().Type().(*types.Pointer); isPointer {
 		// Methods with pointer-receiver are only attached to the pointer-receiver
 		// type.
 		return primaryFunction(ptrPrototypeVar)

From 06e892587161be23c3e10221192e3ed464118752 Mon Sep 17 00:00:00 2001
From: Nevkontakte <aleks@nevkontakte.com>
Date: Sat, 20 Jul 2024 22:11:21 +0100
Subject: [PATCH 3/5] Refactor method translation code.

 - Move it into a separate function, similar to
   translateStandaloneFunction().
 - Add some comments explaining quirks of GopherJS's method
   implementation.

(based on commit ccda9188a8667df0860cbc8fa5f428794b247284)
---
 compiler/expressions.go |   5 +-
 compiler/functions.go   | 123 +++++++++++++++++++++-------------------
 compiler/utils.go       |  15 +++++
 3 files changed, 80 insertions(+), 63 deletions(-)

diff --git a/compiler/expressions.go b/compiler/expressions.go
index fea80b65a..c72d91a83 100644
--- a/compiler/expressions.go
+++ b/compiler/expressions.go
@@ -730,10 +730,7 @@ func (fc *funcContext) translateExpr(expr ast.Expr) *expression {
 					}
 				}
 
-				methodName := sel.Obj().Name()
-				if reservedKeywords[methodName] {
-					methodName += "$"
-				}
+				methodName := fc.methodName(sel.Obj().(*types.Func))
 				return fc.translateCall(e, sig, fc.formatExpr("%s.%s", recv, methodName))
 
 			case types.FieldVal:
diff --git a/compiler/functions.go b/compiler/functions.go
index 54d857719..c9fdaab30 100644
--- a/compiler/functions.go
+++ b/compiler/functions.go
@@ -5,6 +5,7 @@ package compiler
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"go/ast"
 	"go/types"
@@ -21,10 +22,10 @@ import (
 // to the provided info and instance.
 func (fc *funcContext) nestedFunctionContext(info *analysis.FuncInfo, sig *types.Signature, inst typeparams.Instance) *funcContext {
 	if info == nil {
-		panic(fmt.Errorf("missing *analysis.FuncInfo"))
+		panic(errors.New("missing *analysis.FuncInfo"))
 	}
 	if sig == nil {
-		panic(fmt.Errorf("missing *types.Signature"))
+		panic(errors.New("missing *types.Signature"))
 	}
 
 	c := &funcContext{
@@ -59,7 +60,7 @@ func (fc *funcContext) nestedFunctionContext(info *analysis.FuncInfo, sig *types
 // translateTopLevelFunction translates a top-level function declaration
 // (standalone function or method) into a corresponding JS function.
 //
-// Returns a string with a JavaScript statements that define the function or
+// Returns a string with JavaScript statements that define the function or
 // method. For methods it returns declarations for both value- and
 // pointer-receiver (if appropriate).
 func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl, inst typeparams.Instance) []byte {
@@ -67,8 +68,45 @@ func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl, inst typepar
 		return fc.translateStandaloneFunction(fun, inst)
 	}
 
+	return fc.translateMethod(fun, inst)
+}
+
+// translateStandaloneFunction translates a package-level function.
+//
+// It returns JS statements which define the corresponding function in a
+// package context. Exported functions are also assigned to the `$pkg` object.
+func (fc *funcContext) translateStandaloneFunction(fun *ast.FuncDecl, inst typeparams.Instance) []byte {
 	o := inst.Object.(*types.Func)
 	info := fc.pkgCtx.FuncDeclInfos[o]
+	sig := o.Type().(*types.Signature)
+
+	if fun.Recv != nil {
+		panic(fmt.Errorf("expected standalone function, got method: %s", o))
+	}
+
+	lvalue := fc.instName(inst)
+
+	if fun.Body == nil {
+		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fc.unimplementedFunction(o)))
+	}
+
+	body := fc.nestedFunctionContext(info, sig, inst).translateFunctionBody(fun.Type, nil, fun.Body, lvalue)
+	code := bytes.NewBuffer(nil)
+	fmt.Fprintf(code, "\t%s = %s;\n", lvalue, body)
+	if fun.Name.IsExported() {
+		fmt.Fprintf(code, "\t$pkg.%s = %s;\n", encodeIdent(fun.Name.Name), lvalue)
+	}
+	return code.Bytes()
+}
+
+// translateMethod translates a named type method.
+//
+// It returns one or more JS statements which define the method. Methods with
+// non-pointer receiver are automatically defined for the pointer-receiver type.
+func (fc *funcContext) translateMethod(fun *ast.FuncDecl, inst typeparams.Instance) []byte {
+	o := inst.Object.(*types.Func)
+	info := fc.pkgCtx.FuncDeclInfos[o]
+	funName := fc.methodName(o)
 
 	sig := o.Type().(*types.Signature)
 	// primaryFunction generates a JS function equivalent of the current Go function
@@ -86,19 +124,6 @@ func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl, inst typepar
 		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fun))
 	}
 
-	funName := fun.Name.Name
-	if reservedKeywords[funName] {
-		funName += "$"
-	}
-
-	// proxyFunction generates a JS function that forwards the call to the actual
-	// method implementation for the alternate receiver (e.g. pointer vs
-	// non-pointer).
-	proxyFunction := func(lvalue, receiver string) []byte {
-		fun := fmt.Sprintf("function(...$args) { return %s.%s(...$args); }", receiver, funName)
-		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fun))
-	}
-
 	recvInst := inst.Recv()
 	recvInstName := fc.instName(recvInst)
 	recvType := recvInst.Object.Type().(*types.Named)
@@ -108,61 +133,41 @@ func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl, inst typepar
 	prototypeVar := fmt.Sprintf("%s.prototype.%s", recvInstName, funName)
 	ptrPrototypeVar := fmt.Sprintf("$ptrType(%s).prototype.%s", recvInstName, funName)
 
-	code := bytes.NewBuffer(nil)
+	// Methods with pointer-receiver are only attached to the pointer-receiver type.
+	if _, isPointer := sig.Recv().Type().(*types.Pointer); isPointer {
+		return primaryFunction(ptrPrototypeVar)
+	}
+
+	// Methods with non-pointer receivers must be defined both for the pointer
+	// and non-pointer types. To minimize generated code size, we generate a
+	// complete implementation for only one receiver (non-pointer for most types)
+	// and define a proxy function on the other, which converts the receiver type
+	// and forwards the call to the primary implementation.
+	proxyFunction := func(lvalue, receiver string) []byte {
+		fun := fmt.Sprintf("function(...$args) { return %s.%s(...$args); }", receiver, funName)
+		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fun))
+	}
 
+	// Structs are a special case: they are represented by JS objects and their
+	// methods are the underlying object's methods. Due to reference semantics of
+	// the JS variables, the actual backing object is considered to represent the
+	// pointer-to-struct type, and methods are attacher to it first and foremost.
 	if _, isStruct := recvType.Underlying().(*types.Struct); isStruct {
-		// Structs are a special case: they are represented by JS objects and their
-		// methods are the underlying object's methods. Due to reference semantics
-		// of the JS variables, the actual backing object is considered to represent
-		// the pointer-to-struct type, and methods are attacher to it first and
-		// foremost.
+		code := bytes.Buffer{}
 		code.Write(primaryFunction(ptrPrototypeVar))
 		code.Write(proxyFunction(prototypeVar, "this.$val"))
 		return code.Bytes()
 	}
 
-	if _, isPointer := sig.Recv().Type().(*types.Pointer); isPointer {
-		// Methods with pointer-receiver are only attached to the pointer-receiver
-		// type.
-		return primaryFunction(ptrPrototypeVar)
-	}
-
 	// Methods defined for non-pointer receiver are attached to both pointer- and
 	// non-pointer-receiver types.
-	recvExpr := "this.$get()"
+	proxyRecvExpr := "this.$get()"
 	if isWrapped(recvType) {
-		recvExpr = fmt.Sprintf("new %s(%s)", recvInstName, recvExpr)
+		proxyRecvExpr = fmt.Sprintf("new %s(%s)", recvInstName, proxyRecvExpr)
 	}
+	code := bytes.Buffer{}
 	code.Write(primaryFunction(prototypeVar))
-	code.Write(proxyFunction(ptrPrototypeVar, recvExpr))
-	return code.Bytes()
-}
-
-// translateStandaloneFunction translates a package-level function.
-//
-// It returns a JS statements which define the corresponding function in a
-// package context. Exported functions are also assigned to the `$pkg` object.
-func (fc *funcContext) translateStandaloneFunction(fun *ast.FuncDecl, inst typeparams.Instance) []byte {
-	o := inst.Object.(*types.Func)
-	info := fc.pkgCtx.FuncDeclInfos[o]
-	sig := o.Type().(*types.Signature)
-
-	if fun.Recv != nil {
-		panic(fmt.Errorf("expected standalone function, got method: %s", o))
-	}
-
-	lvalue := fc.instName(inst)
-
-	if fun.Body == nil {
-		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fc.unimplementedFunction(o)))
-	}
-
-	body := fc.nestedFunctionContext(info, sig, inst).translateFunctionBody(fun.Type, nil, fun.Body, lvalue)
-	code := bytes.NewBuffer(nil)
-	fmt.Fprintf(code, "\t%s = %s;\n", lvalue, body)
-	if fun.Name.IsExported() {
-		fmt.Fprintf(code, "\t$pkg.%s = %s;\n", encodeIdent(fun.Name.Name), lvalue)
-	}
+	code.Write(proxyFunction(ptrPrototypeVar, proxyRecvExpr))
 	return code.Bytes()
 }
 
diff --git a/compiler/utils.go b/compiler/utils.go
index 7fec5b223..1911f5b2a 100644
--- a/compiler/utils.go
+++ b/compiler/utils.go
@@ -474,6 +474,21 @@ func (fc *funcContext) instName(inst typeparams.Instance) string {
 	return fmt.Sprintf("%s[%d /* %v */]", objName, fc.pkgCtx.instanceSet.ID(inst), inst.TArgs)
 }
 
+// methodName returns a JS identifier (specifically, object property name)
+// corresponding to the given method.
+func (fc *funcContext) methodName(fun *types.Func) string {
+	if fun.Type().(*types.Signature).Recv() == nil {
+		panic(fmt.Errorf("expected a method, got a standalone function %v", fun))
+	}
+	name := fun.Name()
+	// Method names are scoped to their receiver type and guaranteed to be
+	// unique within that, so we only need to make sure it's not a reserved keyword
+	if reservedKeywords[name] {
+		name += "$"
+	}
+	return name
+}
+
 func (fc *funcContext) varPtrName(o *types.Var) string {
 	if isPkgLevel(o) && o.Exported() {
 		return fc.pkgVar(o.Pkg()) + "." + o.Name() + "$ptr"

From d5771cc9f6b734ddfe33789060b8dc87f93b6905 Mon Sep 17 00:00:00 2001
From: Nevkontakte <aleks@nevkontakte.com>
Date: Sun, 21 Jul 2024 00:17:31 +0100
Subject: [PATCH 4/5] Assign identity to all function literals and use them as
 funcRefs.

The main change is that we assign explicit names to all function objects
that correspond to Go functions (named and literals). Function name is
declared as `var f = function nameHere() { ... }` and is visible inside
the function scope only. Doing so serves two purposes:

 - It is an identifier which we can use when saving state of a blocked
   function to know which function to call upon resumption.
 - It shows up in the stack trace, which helps distinguish
   similarly-named functions. For methods, we include the receiver type
   in the identifier to make A.String and B.String easily
   distinguishable.

The main trick is that we synthesize names for the function literals,
which are anonymous as far as go/types is concerned. The upstream Go
compiler does something very similar.

(based on commit 4d2439585cd7b83a77e8fa81c3f4cee692be3162)
---
 compiler/decls.go                       |  2 +-
 compiler/expressions.go                 |  2 +-
 compiler/functions.go                   | 89 ++++++++++++++++---------
 compiler/natives/src/reflect/reflect.go | 22 +++---
 compiler/package.go                     | 11 +++
 compiler/utils.go                       | 44 +++++++++++-
 6 files changed, 127 insertions(+), 43 deletions(-)

diff --git a/compiler/decls.go b/compiler/decls.go
index 36f97d3ff..c134bc44b 100644
--- a/compiler/decls.go
+++ b/compiler/decls.go
@@ -345,7 +345,7 @@ func (fc *funcContext) newFuncDecl(fun *ast.FuncDecl, inst typeparams.Instance)
 	}
 
 	d.DceDeps = fc.CollectDCEDeps(func() {
-		d.DeclCode = fc.translateTopLevelFunction(fun, inst)
+		d.DeclCode = fc.namedFuncContext(inst).translateTopLevelFunction(fun)
 	})
 	return d
 }
diff --git a/compiler/expressions.go b/compiler/expressions.go
index c72d91a83..5652439fe 100644
--- a/compiler/expressions.go
+++ b/compiler/expressions.go
@@ -201,7 +201,7 @@ func (fc *funcContext) translateExpr(expr ast.Expr) *expression {
 		}
 
 	case *ast.FuncLit:
-		fun := fc.nestedFunctionContext(fc.pkgCtx.FuncLitInfos[e], exprType.(*types.Signature), typeparams.Instance{}).translateFunctionBody(e.Type, nil, e.Body, "")
+		fun := fc.literalFuncContext(e).translateFunctionBody(e.Type, nil, e.Body)
 		if len(fc.pkgCtx.escapingVars) != 0 {
 			names := make([]string, 0, len(fc.pkgCtx.escapingVars))
 			for obj := range fc.pkgCtx.escapingVars {
diff --git a/compiler/functions.go b/compiler/functions.go
index c9fdaab30..31a9974eb 100644
--- a/compiler/functions.go
+++ b/compiler/functions.go
@@ -18,18 +18,21 @@ import (
 	"github.com/gopherjs/gopherjs/compiler/typesutil"
 )
 
-// newFunctionContext creates a new nested context for a function corresponding
+// nestedFunctionContext creates a new nested context for a function corresponding
 // to the provided info and instance.
-func (fc *funcContext) nestedFunctionContext(info *analysis.FuncInfo, sig *types.Signature, inst typeparams.Instance) *funcContext {
+func (fc *funcContext) nestedFunctionContext(info *analysis.FuncInfo, inst typeparams.Instance) *funcContext {
 	if info == nil {
 		panic(errors.New("missing *analysis.FuncInfo"))
 	}
-	if sig == nil {
-		panic(errors.New("missing *types.Signature"))
+	if inst.Object == nil {
+		panic(errors.New("missing inst.Object"))
 	}
+	o := inst.Object.(*types.Func)
+	sig := o.Type().(*types.Signature)
 
 	c := &funcContext{
 		FuncInfo:     info,
+		instance:     inst,
 		pkgCtx:       fc.pkgCtx,
 		parent:       fc,
 		allVars:      make(map[string]int, len(fc.allVars)),
@@ -54,43 +57,73 @@ func (fc *funcContext) nestedFunctionContext(info *analysis.FuncInfo, sig *types
 		c.objectNames = map[types.Object]string{}
 	}
 
+	// Synthesize an identifier by which the function may reference itself. Since
+	// it appears in the stack trace, it's useful to include the receiver type in
+	// it.
+	funcRef := o.Name()
+	if recvType := typesutil.RecvType(sig); recvType != nil {
+		funcRef = recvType.Obj().Name() + midDot + funcRef
+	}
+	c.funcRef = c.newVariable(funcRef, true /*pkgLevel*/)
+
+	return c
+}
+
+// namedFuncContext creates a new funcContext for a named Go function
+// (standalone or method).
+func (fc *funcContext) namedFuncContext(inst typeparams.Instance) *funcContext {
+	info := fc.pkgCtx.FuncDeclInfos[inst.Object.(*types.Func)]
+	c := fc.nestedFunctionContext(info, inst)
+
+	return c
+}
+
+// literalFuncContext creates a new funcContext for a function literal. Since
+// go/types doesn't generate *types.Func objects for function literals, we
+// generate a synthetic one for it.
+func (fc *funcContext) literalFuncContext(fun *ast.FuncLit) *funcContext {
+	info := fc.pkgCtx.FuncLitInfos[fun]
+	sig := fc.pkgCtx.TypeOf(fun).(*types.Signature)
+	o := types.NewFunc(fun.Pos(), fc.pkgCtx.Pkg, fc.newLitFuncName(), sig)
+	inst := typeparams.Instance{Object: o}
+
+	c := fc.nestedFunctionContext(info, inst)
 	return c
 }
 
 // translateTopLevelFunction translates a top-level function declaration
-// (standalone function or method) into a corresponding JS function.
+// (standalone function or method) into a corresponding JS function. Must be
+// called on the function context created for the function corresponding instance.
 //
 // Returns a string with JavaScript statements that define the function or
 // method. For methods it returns declarations for both value- and
 // pointer-receiver (if appropriate).
-func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl, inst typeparams.Instance) []byte {
+func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl) []byte {
 	if fun.Recv == nil {
-		return fc.translateStandaloneFunction(fun, inst)
+		return fc.translateStandaloneFunction(fun)
 	}
 
-	return fc.translateMethod(fun, inst)
+	return fc.translateMethod(fun)
 }
 
 // translateStandaloneFunction translates a package-level function.
 //
 // It returns JS statements which define the corresponding function in a
 // package context. Exported functions are also assigned to the `$pkg` object.
-func (fc *funcContext) translateStandaloneFunction(fun *ast.FuncDecl, inst typeparams.Instance) []byte {
-	o := inst.Object.(*types.Func)
-	info := fc.pkgCtx.FuncDeclInfos[o]
-	sig := o.Type().(*types.Signature)
+func (fc *funcContext) translateStandaloneFunction(fun *ast.FuncDecl) []byte {
+	o := fc.instance.Object.(*types.Func)
 
 	if fun.Recv != nil {
 		panic(fmt.Errorf("expected standalone function, got method: %s", o))
 	}
 
-	lvalue := fc.instName(inst)
+	lvalue := fc.instName(fc.instance)
 
 	if fun.Body == nil {
 		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fc.unimplementedFunction(o)))
 	}
 
-	body := fc.nestedFunctionContext(info, sig, inst).translateFunctionBody(fun.Type, nil, fun.Body, lvalue)
+	body := fc.translateFunctionBody(fun.Type, nil, fun.Body)
 	code := bytes.NewBuffer(nil)
 	fmt.Fprintf(code, "\t%s = %s;\n", lvalue, body)
 	if fun.Name.IsExported() {
@@ -103,12 +136,10 @@ func (fc *funcContext) translateStandaloneFunction(fun *ast.FuncDecl, inst typep
 //
 // It returns one or more JS statements which define the method. Methods with
 // non-pointer receiver are automatically defined for the pointer-receiver type.
-func (fc *funcContext) translateMethod(fun *ast.FuncDecl, inst typeparams.Instance) []byte {
-	o := inst.Object.(*types.Func)
-	info := fc.pkgCtx.FuncDeclInfos[o]
+func (fc *funcContext) translateMethod(fun *ast.FuncDecl) []byte {
+	o := fc.instance.Object.(*types.Func)
 	funName := fc.methodName(o)
 
-	sig := o.Type().(*types.Signature)
 	// primaryFunction generates a JS function equivalent of the current Go function
 	// and assigns it to the JS expression defined by lvalue.
 	primaryFunction := func(lvalue string) []byte {
@@ -120,11 +151,11 @@ func (fc *funcContext) translateMethod(fun *ast.FuncDecl, inst typeparams.Instan
 		if fun.Recv != nil && fun.Recv.List[0].Names != nil {
 			recv = fun.Recv.List[0].Names[0]
 		}
-		fun := fc.nestedFunctionContext(info, sig, inst).translateFunctionBody(fun.Type, recv, fun.Body, lvalue)
+		fun := fc.translateFunctionBody(fun.Type, recv, fun.Body)
 		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fun))
 	}
 
-	recvInst := inst.Recv()
+	recvInst := fc.instance.Recv()
 	recvInstName := fc.instName(recvInst)
 	recvType := recvInst.Object.Type().(*types.Named)
 
@@ -134,7 +165,7 @@ func (fc *funcContext) translateMethod(fun *ast.FuncDecl, inst typeparams.Instan
 	ptrPrototypeVar := fmt.Sprintf("$ptrType(%s).prototype.%s", recvInstName, funName)
 
 	// Methods with pointer-receiver are only attached to the pointer-receiver type.
-	if _, isPointer := sig.Recv().Type().(*types.Pointer); isPointer {
+	if _, isPointer := fc.sig.Sig.Recv().Type().(*types.Pointer); isPointer {
 		return primaryFunction(ptrPrototypeVar)
 	}
 
@@ -185,7 +216,7 @@ func (fc *funcContext) unimplementedFunction(o *types.Func) string {
 // It returns a JS function expression that represents the given Go function.
 // Function receiver must have been created with nestedFunctionContext() to have
 // required metadata set up.
-func (fc *funcContext) translateFunctionBody(typ *ast.FuncType, recv *ast.Ident, body *ast.BlockStmt, funcRef string) string {
+func (fc *funcContext) translateFunctionBody(typ *ast.FuncType, recv *ast.Ident, body *ast.BlockStmt) string {
 	prevEV := fc.pkgCtx.escapingVars
 
 	// Generate a list of function argument variables. Since Go allows nameless
@@ -239,7 +270,7 @@ func (fc *funcContext) translateFunctionBody(typ *ast.FuncType, recv *ast.Ident,
 
 	sort.Strings(fc.localVars)
 
-	var prefix, suffix, functionName string
+	var prefix, suffix string
 
 	if len(fc.Flattened) != 0 {
 		// $s contains an index of the switch case a blocking function reached
@@ -260,21 +291,19 @@ func (fc *funcContext) translateFunctionBody(typ *ast.FuncType, recv *ast.Ident,
 	localVarDefs := "" // Function-local var declaration at the top.
 
 	if len(fc.Blocking) != 0 {
-		if funcRef == "" {
-			funcRef = "$b"
-			functionName = " $b"
-		}
-
 		localVars := append([]string{}, fc.localVars...)
 		// There are several special variables involved in handling blocking functions:
 		// $r is sometimes used as a temporary variable to store blocking call result.
 		// $c indicates that a function is being resumed after a blocking call when set to true.
 		// $f is an object used to save and restore function context for blocking calls.
 		localVars = append(localVars, "$r")
+		// funcRef identifies the function object itself, so it doesn't need to be saved
+		// or restored.
+		localVars = removeMatching(localVars, fc.funcRef)
 		// If a blocking function is being resumed, initialize local variables from the saved context.
 		localVarDefs = fmt.Sprintf("var {%s, $c} = $restore(this, {%s});\n", strings.Join(localVars, ", "), strings.Join(args, ", "))
 		// If the function gets blocked, save local variables for future.
-		saveContext := fmt.Sprintf("var $f = {$blk: "+funcRef+", $c: true, $r, %s};", strings.Join(fc.localVars, ", "))
+		saveContext := fmt.Sprintf("var $f = {$blk: "+fc.funcRef+", $c: true, $r, %s};", strings.Join(fc.localVars, ", "))
 
 		suffix = " " + saveContext + "return $f;" + suffix
 	} else if len(fc.localVars) > 0 {
@@ -322,5 +351,5 @@ func (fc *funcContext) translateFunctionBody(typ *ast.FuncType, recv *ast.Ident,
 
 	fc.pkgCtx.escapingVars = prevEV
 
-	return fmt.Sprintf("function%s(%s) {\n%s%s}", functionName, strings.Join(args, ", "), bodyOutput, fc.Indentation(0))
+	return fmt.Sprintf("function %s(%s) {\n%s%s}", fc.funcRef, strings.Join(args, ", "), bodyOutput, fc.Indentation(0))
 }
diff --git a/compiler/natives/src/reflect/reflect.go b/compiler/natives/src/reflect/reflect.go
index 47b93662e..81f4c7b08 100644
--- a/compiler/natives/src/reflect/reflect.go
+++ b/compiler/natives/src/reflect/reflect.go
@@ -1778,26 +1778,28 @@ func valueMethodName() string {
 	var pc [5]uintptr
 	n := runtime.Callers(1, pc[:])
 	frames := runtime.CallersFrames(pc[:n])
+	valueTyp := TypeOf(Value{})
 	var frame runtime.Frame
 	for more := true; more; {
 		frame, more = frames.Next()
 		name := frame.Function
-
 		// Function name extracted from the call stack can be different from
 		// vanilla Go, so is not prefixed by "reflect.Value." as needed by the original.
 		// See https://cs.opensource.google/go/go/+/refs/tags/go1.19.13:src/reflect/value.go;l=173-191
-		// Here we try to fix stuff like "Object.$packages.reflect.Q.ptr.SetIterKey"
-		// into "reflect.Value.SetIterKey".
 		// This workaround may become obsolete after
 		// https://github.com/gopherjs/gopherjs/issues/1085 is resolved.
 
-		const prefix = `Object.$packages.reflect.`
-		if stringsHasPrefix(name, prefix) {
-			if idx := stringsLastIndex(name, '.'); idx >= 0 {
-				methodName := name[idx+1:]
-				if len(methodName) > 0 && 'A' <= methodName[0] && methodName[0] <= 'Z' {
-					return `reflect.Value.` + methodName
-				}
+		methodName := name
+		if idx := stringsLastIndex(name, '.'); idx >= 0 {
+			methodName = name[idx+1:]
+		}
+
+		// Since function name in the call stack doesn't contain receiver name,
+		// we are looking for the first exported function name that matches a
+		// known Value method.
+		if _, ok := valueTyp.MethodByName(methodName); ok {
+			if len(methodName) > 0 && 'A' <= methodName[0] && methodName[0] <= 'Z' {
+				return `reflect.Value.` + methodName
 			}
 		}
 	}
diff --git a/compiler/package.go b/compiler/package.go
index 34387b5ab..bcdfca514 100644
--- a/compiler/package.go
+++ b/compiler/package.go
@@ -53,6 +53,15 @@ func (pc *pkgContext) isMain() bool {
 // JavaScript code (as defined for `var` declarations).
 type funcContext struct {
 	*analysis.FuncInfo
+	// Function instance this context corresponds to, or zero if the context is
+	// top-level or doesn't correspond to a function. For function literals, this
+	// is a synthetic object that assigns a unique identity to the function.
+	instance typeparams.Instance
+	// JavaScript identifier assigned to the function object (the word after the
+	// "function" keyword in the generated code). This identifier can be used
+	// within the function scope to reference the function object. It will also
+	// appear in the stack trace.
+	funcRef string
 	// Surrounding package context.
 	pkgCtx *pkgContext
 	// Function context, surrounding this function definition. For package-level
@@ -104,6 +113,8 @@ type funcContext struct {
 	typeResolver *typeparams.Resolver
 	// Mapping from function-level objects to JS variable names they have been assigned.
 	objectNames map[types.Object]string
+	// Number of function literals encountered within the current function context.
+	funcLitCounter int
 }
 
 func newRootCtx(tContext *types.Context, srcs sources, typesInfo *types.Info, typesPkg *types.Package, isBlocking func(*types.Func) bool, minify bool) *funcContext {
diff --git a/compiler/utils.go b/compiler/utils.go
index 1911f5b2a..62c09a09d 100644
--- a/compiler/utils.go
+++ b/compiler/utils.go
@@ -23,6 +23,11 @@ import (
 	"github.com/gopherjs/gopherjs/compiler/typesutil"
 )
 
+// We use this character as a separator in synthetic identifiers instead of a
+// regular dot. This character is safe for use in JS identifiers and helps to
+// visually separate components of the name when it appears in a stack trace.
+const midDot = "·"
+
 // root returns the topmost function context corresponding to the package scope.
 func (fc *funcContext) root() *funcContext {
 	if fc.isRoot() {
@@ -376,6 +381,25 @@ func (fc *funcContext) newTypeIdent(name string, obj types.Object) *ast.Ident {
 	return ident
 }
 
+// newLitFuncName generates a new synthetic name for a function literal.
+func (fc *funcContext) newLitFuncName() string {
+	fc.funcLitCounter++
+	name := &strings.Builder{}
+
+	// If function literal is defined inside another function, qualify its
+	// synthetic name with the outer function to make it easier to identify.
+	if fc.instance.Object != nil {
+		if recvType := typesutil.RecvType(fc.sig.Sig); recvType != nil {
+			name.WriteString(recvType.Obj().Name())
+			name.WriteString(midDot)
+		}
+		name.WriteString(fc.instance.Object.Name())
+		name.WriteString(midDot)
+	}
+	fmt.Fprintf(name, "func%d", fc.funcLitCounter)
+	return name.String()
+}
+
 func (fc *funcContext) setType(e ast.Expr, t types.Type) ast.Expr {
 	fc.pkgCtx.Types[e] = types.TypeAndValue{Type: t}
 	return e
@@ -909,7 +933,15 @@ func rangeCheck(pattern string, constantIndex, array bool) string {
 }
 
 func encodeIdent(name string) string {
-	return strings.Replace(url.QueryEscape(name), "%", "$", -1)
+	// Quick-and-dirty way to make any string safe for use as an identifier in JS.
+	name = url.QueryEscape(name)
+	// We use unicode middle dot as a visual separator in synthetic identifiers.
+	// It is safe for use in a JS identifier, so we un-encode it for readability.
+	name = strings.ReplaceAll(name, "%C2%B7", midDot)
+	// QueryEscape uses '%' before hex-codes of escaped characters, which is not
+	// allowed in a JS identifier, use '$' instead.
+	name = strings.ReplaceAll(name, "%", "$")
+	return name
 }
 
 // formatJSStructTagVal returns JavaScript code for accessing an object's property
@@ -995,3 +1027,13 @@ func bailingOut(err interface{}) (*FatalError, bool) {
 	fe, ok := err.(*FatalError)
 	return fe, ok
 }
+
+func removeMatching[T comparable](haystack []T, needle T) []T {
+	var result []T
+	for _, el := range haystack {
+		if el != needle {
+			result = append(result, el)
+		}
+	}
+	return result
+}

From 4ebc56caf2e980f9e3dd2416797406d1d42802a3 Mon Sep 17 00:00:00 2001
From: Nevkontakte <aleks@nevkontakte.com>
Date: Sat, 3 Aug 2024 16:36:33 +0100
Subject: [PATCH 5/5] Temporarily disable reflect tests that depend on caller
 function names.

JS function names are subtly different from what vanilla Go may expect,
unless https://github.com/gopherjs/gopherjs/issues/1085 is implemented.
It turns out that a combination of
d5771cc9f6b734ddfe33789060b8dc87f93b6905 and 22c65b81261d6ee21767ef6929d51e43b9e99047
subtly changes how node outputs stack trace in a way that breaks my
workarounds in the reflect package.

Instead of further fumbling, I am going to disable the offending tests
temporarily, and I have a proper fix for #1085 in the works, which will
allow us to re-enable them along with a few other tests.
---
 compiler/natives/src/reflect/reflect_test.go | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/compiler/natives/src/reflect/reflect_test.go b/compiler/natives/src/reflect/reflect_test.go
index 79bbe5385..4c0bcd0be 100644
--- a/compiler/natives/src/reflect/reflect_test.go
+++ b/compiler/natives/src/reflect/reflect_test.go
@@ -298,3 +298,23 @@ func TestIssue50208(t *testing.T) {
 func TestStructOfTooLarge(t *testing.T) {
 	t.Skip("This test is dependent on field alignment to determine if a struct size would exceed virtual address space.")
 }
+
+func TestSetLenCap(t *testing.T) {
+	t.Skip("Test depends on call stack function names: https://github.com/gopherjs/gopherjs/issues/1085")
+}
+
+func TestSetPanic(t *testing.T) {
+	t.Skip("Test depends on call stack function names: https://github.com/gopherjs/gopherjs/issues/1085")
+}
+
+func TestCallPanic(t *testing.T) {
+	t.Skip("Test depends on call stack function names: https://github.com/gopherjs/gopherjs/issues/1085")
+}
+
+func TestValuePanic(t *testing.T) {
+	t.Skip("Test depends on call stack function names: https://github.com/gopherjs/gopherjs/issues/1085")
+}
+
+func TestSetIter(t *testing.T) {
+	t.Skip("Test depends on call stack function names: https://github.com/gopherjs/gopherjs/issues/1085")
+}