reflect: Fix test failures introduced in Go 1.18.

nevkontakte · nevkontakte · commit aa9b527c13ec · 2022-07-10T20:59:06.000+01:00
- Avoid use of unsafe in TestNestedMethods and TestEmbeddedMethods. - Skip TestNotInHeapDeref and TestMethodCallValueCodePtr, which concern low-level GC and heap details, inapplicable to GopherJS. - Skip TestIssue50208 until generics are supported. - Add a hack into methodNameSkip() to make method names match what the tests expect. #1085 would be a better long-term solution. - Stub out verifyNotInHeapPtr(), which is also not applicable to GopherJS.
diff --git a/compiler/natives/src/reflect/reflect.go b/compiler/natives/src/reflect/reflect.go
@@ -5,6 +5,7 @@ package reflect
 
 import (
 	"errors"
+	"runtime"
 	"strconv"
 	"unsafe"
 
@@ -1725,3 +1726,35 @@ func deepValueEqualJs(v1, v2 Value, visited [][2]unsafe.Pointer) bool {
 
 	return js.Global.Call("$interfaceIsEqual", js.InternalObject(valueInterface(v1, false)), js.InternalObject(valueInterface(v2, false))).Bool()
 }
+
+func methodNameSkip() string {
+	pc, _, _, _ := runtime.Caller(3)
+	f := runtime.FuncForPC(pc)
+	if f == nil {
+		return "unknown method"
+	}
+	// Function name extracted from the call stack can be different from vanilla
+	// Go. Here we try to fix stuff like "Object.$packages.reflect.Q.ptr.SetIterKey"
+	// into "Value.SetIterKey".
+	// This workaround may become obsolete after https://github.com/gopherjs/gopherjs/issues/1085
+	// is resolved.
+	name := f.Name()
+	idx := len(name) - 1
+	for idx > 0 {
+		if name[idx] == '.' {
+			break
+		}
+		idx--
+	}
+	if idx < 0 {
+		return name
+	}
+	return "Value" + name[idx:]
+}
+
+func verifyNotInHeapPtr(p uintptr) bool {
+	// Go runtime uses this method to make sure that a uintptr won't crash GC if
+	// interpreted as a heap pointer. This is not relevant for GopherJS, so we can
+	// always return true.
+	return true
+}
diff --git a/compiler/natives/src/reflect/reflect_test.go b/compiler/natives/src/reflect/reflect_test.go
@@ -214,3 +214,77 @@ func TestMapIterSet(t *testing.T) {
 	// Upstream test also tests allocations made by the iterator. GopherJS doesn't
 	// support runtime.ReadMemStats(), so we leave that part out.
 }
+
+type inner struct {
+	x int
+}
+
+type outer struct {
+	y int
+	inner
+}
+
+func (*inner) M() int { return 1 }
+func (*outer) M() int { return 2 }
+
+func TestNestedMethods(t *testing.T) {
+	// This test is similar to the upstream, but avoids using the unsupported
+	// Value.UnsafePointer() method.
+	typ := TypeOf((*outer)(nil))
+	args := []Value{
+		ValueOf((*outer)(nil)), // nil receiver
+	}
+	if typ.NumMethod() != 1 {
+		t.Errorf("Wrong method table for outer, found methods:")
+		for i := 0; i < typ.NumMethod(); i++ {
+			m := typ.Method(i)
+			t.Errorf("\t%d: %s\n", i, m.Name)
+		}
+	}
+	if got := typ.Method(0).Func.Call(args)[0]; got.Int() != 2 {
+		t.Errorf("Wrong method table for outer, expected return value 2, got: %v", got)
+	}
+	if got := ValueOf((*outer).M).Call(args)[0]; got.Int() != 2 {
+		t.Errorf("Wrong method table for outer, expected return value 2, got: %v", got)
+	}
+}
+
+func TestEmbeddedMethods(t *testing.T) {
+	// This test is similar to the upstream, but avoids using the unsupported
+	// Value.UnsafePointer() method.
+	typ := TypeOf((*OuterInt)(nil))
+	if typ.NumMethod() != 1 {
+		t.Errorf("Wrong method table for OuterInt: (m=%p)", (*OuterInt).M)
+		for i := 0; i < typ.NumMethod(); i++ {
+			m := typ.Method(i)
+			t.Errorf("\t%d: %s %p\n", i, m.Name, m.Func.UnsafePointer())
+		}
+	}
+
+	i := &InnerInt{3}
+	if v := ValueOf(i).Method(0).Call(nil)[0].Int(); v != 3 {
+		t.Errorf("i.M() = %d, want 3", v)
+	}
+
+	o := &OuterInt{1, InnerInt{2}}
+	if v := ValueOf(o).Method(0).Call(nil)[0].Int(); v != 2 {
+		t.Errorf("i.M() = %d, want 2", v)
+	}
+
+	f := (*OuterInt).M
+	if v := f(o); v != 2 {
+		t.Errorf("f(o) = %d, want 2", v)
+	}
+}
+
+func TestNotInHeapDeref(t *testing.T) {
+	t.Skip("GopherJS doesn't support //go:notinheap")
+}
+
+func TestMethodCallValueCodePtr(t *testing.T) {
+	t.Skip("methodValueCallCodePtr() is not applicable in GopherJS")
+}
+
+func TestIssue50208(t *testing.T) {
+	t.Skip("This test required generics, which are not yet supported: https://github.com/gopherjs/gopherjs/issues/1013")
+}
