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 fea80b65a..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 {
@@ -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 ed3062c60..31a9974eb 100644
--- a/compiler/functions.go
+++ b/compiler/functions.go
@@ -5,6 +5,7 @@ package compiler
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"go/ast"
 	"go/types"
@@ -17,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(fmt.Errorf("missing *analysis.FuncInfo"))
+		panic(errors.New("missing *analysis.FuncInfo"))
 	}
-	if sig == nil {
-		panic(fmt.Errorf("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)),
@@ -53,53 +57,105 @@ 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 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 {
+func (fc *funcContext) translateTopLevelFunction(fun *ast.FuncDecl) []byte {
 	if fun.Recv == nil {
-		return fc.translateStandaloneFunction(fun, inst)
+		return fc.translateStandaloneFunction(fun)
 	}
 
-	o := inst.Object.(*types.Func)
-	info := fc.pkgCtx.FuncDeclInfos[o]
+	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) []byte {
+	o := fc.instance.Object.(*types.Func)
+
+	if fun.Recv != nil {
+		panic(fmt.Errorf("expected standalone function, got method: %s", o))
+	}
+
+	lvalue := fc.instName(fc.instance)
+
+	if fun.Body == nil {
+		return []byte(fmt.Sprintf("\t%s = %s;\n", lvalue, fc.unimplementedFunction(o)))
+	}
+
+	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() {
+		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) []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 {
 		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
 		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)
-		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)
+		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)
 
@@ -108,70 +164,51 @@ 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 := fc.sig.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 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()
-		}
-
-		// 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))
+	code.Write(proxyFunction(ptrPrototypeVar, proxyRecvExpr))
 	return code.Bytes()
 }
 
-// translateStandaloneFunction translates a package-level function.
+// unimplementedFunction returns a JS function expression for a Go function
+// without a body, which would throw an exception if called.
 //
-// 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 = function() {\n\t\t$throwRuntimeError(\"native function not implemented: %s\");\n\t};\n", lvalue, o.FullName()))
-	}
-
-	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()
+// 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.
@@ -179,7 +216,7 @@ func (fc *funcContext) translateStandaloneFunction(fun *ast.FuncDecl, inst typep
 // 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
@@ -233,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
@@ -254,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 {
@@ -316,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/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")
+}
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 7fec5b223..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
@@ -474,6 +498,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"
@@ -894,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
@@ -980,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
+}