Update to reflect and reflectlite

grantnelson-wf · grantnelson-wf · commit 543764212241 · 2024-01-30T17:30:54.000-07:00
diff --git a/compiler/natives/src/internal/reflectlite/all_test.go b/compiler/natives/src/internal/reflectlite/all_test.go
@@ -21,3 +21,27 @@ func TestTypes(t *testing.T) {
 func TestNameBytesAreAligned(t *testing.T) {
 	t.Skip("TestNameBytesAreAligned")
 }
+
+// `A` is used with `B[T any]` and is otherwise not needed.
+//
+//gopherjs:purge for go1.19 without generics
+type (
+	A        struct{}
+	B[T any] struct{}
+)
+
+// removing the name tests using `B[T any]` for go1.19 without generics
+var nameTests = []nameTest{
+	{(*int32)(nil), "int32"},
+	{(*D1)(nil), "D1"},
+	{(*[]D1)(nil), ""},
+	{(*chan D1)(nil), ""},
+	{(*func() D1)(nil), ""},
+	{(*<-chan D1)(nil), ""},
+	{(*chan<- D1)(nil), ""},
+	{(*any)(nil), ""},
+	{(*interface {
+		F()
+	})(nil), ""},
+	{(*TheNameOfThisTypeIsExactly255BytesLongSoWhenTheCompilerPrependsTheReflectTestPackageNameAndExtraStarTheLinkerRuntimeAndReflectPackagesWillHaveToCorrectlyDecodeTheSecondLengthByte0123456789_0123456789_0123456789_0123456789_0123456789_012345678)(nil), "TheNameOfThisTypeIsExactly255BytesLongSoWhenTheCompilerPrependsTheReflectTestPackageNameAndExtraStarTheLinkerRuntimeAndReflectPackagesWillHaveToCorrectlyDecodeTheSecondLengthByte0123456789_0123456789_0123456789_0123456789_0123456789_012345678"},
+}
diff --git a/compiler/natives/src/reflect/reflect.go b/compiler/natives/src/reflect/reflect.go
@@ -1179,6 +1179,11 @@ func (v Value) Cap() int {
 		return v.typ.Len()
 	case Chan, Slice:
 		return v.object().Get("$capacity").Int()
+	case Ptr:
+		if v.typ.Elem().Kind() == Array {
+			return v.typ.Elem().Len()
+		}
+		panic("reflect: call of reflect.Value.Cap on ptr to non-array Value")
 	}
 	panic(&ValueError{"reflect.Value.Cap", k})
 }
@@ -1405,6 +1410,11 @@ func (v Value) Len() int {
 		return v.object().Get("$buffer").Get("length").Int()
 	case Map:
 		return v.object().Get("size").Int()
+	case Ptr:
+		if v.typ.Elem().Kind() == Array {
+			return v.typ.Elem().Len()
+		}
+		panic("reflect: call of reflect.Value.Len on ptr to non-array Value")
 	default:
 		panic(&ValueError{"reflect.Value.Len", k})
 	}
@@ -1450,6 +1460,29 @@ func (v Value) Set(x Value) {
 	v.ptr = x.ptr
 }
 
+func (v Value) bytesSlow() []byte {
+	switch v.kind() {
+	case Slice:
+		if v.typ.Elem().Kind() != Uint8 {
+			panic("reflect.Value.Bytes of non-byte slice")
+		}
+		return *(*[]byte)(v.ptr)
+	case Array:
+		if v.typ.Elem().Kind() != Uint8 {
+			panic("reflect.Value.Bytes of non-byte array")
+		}
+		if !v.CanAddr() {
+			panic("reflect.Value.Bytes of unaddressable byte array")
+		}
+		// Replace the following with JS to avoid using unsafe pointers.
+		//   p := (*byte)(v.ptr)
+		//   n := int((*arrayType)(unsafe.Pointer(v.typ)).len)
+		//   return unsafe.Slice(p, n)
+		return js.InternalObject(v.ptr).Interface().([]byte)
+	}
+	panic(&ValueError{"reflect.Value.Bytes", v.kind()})
+}
+
 func (v Value) SetBytes(x []byte) {
 	v.mustBeAssignable()
 	v.mustBe(Slice)
@@ -1728,29 +1761,47 @@ 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
+func stringsLastIndex(s string, c byte) int {
+	for i := len(s) - 1; i >= 0; i-- {
+		if s[i] == c {
+			return i
 		}
-		idx--
 	}
-	if idx < 0 {
-		return name
+	return -1
+}
+
+func stringsHasPrefix(s, prefix string) bool {
+	return len(s) >= len(prefix) && s[:len(prefix)] == prefix
+}
+
+func valueMethodName() string {
+	var pc [5]uintptr
+	n := runtime.Callers(1, pc[:])
+	frames := runtime.CallersFrames(pc[:n])
+	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
+				}
+			}
+		}
 	}
-	return "Value" + name[idx:]
+	return "unknown method"
 }
 
 func verifyNotInHeapPtr(p uintptr) bool {
diff --git a/compiler/natives/src/reflect/reflect_test.go b/compiler/natives/src/reflect/reflect_test.go
@@ -285,9 +285,16 @@ func TestMethodCallValueCodePtr(t *testing.T) {
 	t.Skip("methodValueCallCodePtr() is not applicable in GopherJS")
 }
 
-type B struct{}
+//gopherjs:purge for go1.19 without generics
+type (
+	A        struct{}
+	B[T any] struct{}
+)
 
-//gopherjs:prune-original
 func TestIssue50208(t *testing.T) {
 	t.Skip("This test required generics, which are not yet supported: https://github.com/gopherjs/gopherjs/issues/1013")
 }
+
+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.")
+}
