gopherjs
diff --git a/‎compiler/prelude/types.js
Copy file name to clipboardExpand all lines: compiler/prelude/types.js
+12-1Lines changed: 12 additions & 1 deletion b/‎compiler/prelude/types.js
Copy file name to clipboardExpand all lines: compiler/prelude/types.js
+12-1Lines changed: 12 additions & 1 deletion
diff --git a/‎tests/gorepo/run.go
Copy file name to clipboardExpand all lines: tests/gorepo/run.go
-1Lines changed: 0 additions & 1 deletion b/‎tests/gorepo/run.go
Copy file name to clipboardExpand all lines: tests/gorepo/run.go
-1Lines changed: 0 additions & 1 deletion
diff --git a/‎tests/typeparams/conversion_test.go
Copy file name to clipboardExpand all lines: tests/typeparams/conversion_test.go
+21Lines changed: 21 additions & 0 deletions b/‎tests/typeparams/conversion_test.go
Copy file name to clipboardExpand all lines: tests/typeparams/conversion_test.go
+21Lines changed: 21 additions & 0 deletions
@@ -478,6 +478,7 @@ var $newType = (size, kind, string, named, pkg, exported, constructor) => {
             typ.convertFrom = (src) => $convertToChan(src, typ);
             break;
         case $kindFunc:
+            typ.convertFrom = (src) => $convertToFunc(src, typ);
             break;
         default:
             $panic(new $String("invalid kind: " + kind));
@@ -1214,4 +1215,14 @@ const $convertToMap = (src, dstType) => {
  */
 const $convertToChan = (src, dstType) => {
     return src.$val;
-};
+};
+
+/**
+ * Convert to function types.
+ *
+ * dstType.kind must be $kindFunc. Src must be a wrapped function value. Returned
+ * value will always be a bare JavaScript function.
+ */
+const $convertToFunc = (src, dstType) => {
+    return src.$val;
+};
@@ -168,7 +168,6 @@ var knownFails = map[string]failReason{
 	"typeparam/index2.go":            {category: generics, desc: "missing index operator support for generic types"},
 	"typeparam/issue47258.go":        {category: generics, desc: "missing operator support for generic types"},
 	"typeparam/issue47716.go":        {category: generics, desc: "unsafe.Sizeof() doesn't work with generic types"},
-	"typeparam/issue48137.go":        {category: generics, desc: "unsupported conversion from func() main.Bar to main.Bar"},
 	"typeparam/issue48276a.go":       {category: generics, desc: "missing support for the comparable type constraint"},
 	"typeparam/issue48453.go":        {category: generics, desc: "make() doesn't support generic slice types"},
 	"typeparam/issue49295.go":        {category: generics, desc: "len() doesn't support generic pointer to array types"},
 
@@ -58,6 +58,7 @@ type ( // Named types for use in conversion test cases.
 	arrPtr *[3]byte
 	m      map[string]string
 	ch     chan string
+	fun    func() int
 )
 
 type numeric interface {
@@ -277,11 +278,28 @@ func (tc chanConversion[srcType, dstType]) Run(t *testing.T) {
 	checkConversion(t, tc.src, dstType(tc.src), tc.want)
 }
 
+type funcConversion[srcType ~func() int, dstType ~func() int] struct {
+	src  srcType
+	want dstType
+}
+
+func (tc funcConversion[srcType, dstType]) Run(t *testing.T) {
+	got := dstType(tc.src)
+	if reflect.TypeOf(got) != reflect.TypeOf(tc.want) {
+		t.Errorf("Got: %v. Want: converted type is: %v.", reflect.TypeOf(got), reflect.TypeOf(tc.want))
+	}
+
+	if js.InternalObject(got) != js.InternalObject(tc.want) {
+		t.Errorf("Got: %v != %v. Want: after type conversion function object should remain the same.", got, tc.want)
+	}
+}
+
 func TestConversion(t *testing.T) {
 	strVar := "abc"
 	stVar := st{s: "abc", i: 42}
 	arrVal := [3]byte{1, 2, 3}
 	chanVal := make(chan string)
+	funcVal := func() int { return 42 }
 
 	tests := []conversionTest{
 		// $convertToInt64
@@ -386,6 +404,9 @@ func TestConversion(t *testing.T) {
 		// $convertToChan
 		chanConversion[chan string, ch]{src: chanVal, want: ch(chanVal)},
 		chanConversion[chan string, ch]{src: nil, want: nil},
+		// $convertToFunc
+		funcConversion[func() int, fun]{src: funcVal, want: fun(funcVal)},
+		funcConversion[func() int, fun]{src: nil, want: nil},
 	}
 
 	for _, test := range tests {