Make sure that it is equivalent to v.Interface().(T)

Author: mateusz834

src/reflect/all_test.go

@@ -8701,7 +8701,7 @@ func newPtr[T any](t T) *T {
 	return &t
 }
 
-func TestTypeAssert(t *testing.T) {
+func TestTypeAssertConcreteTypes(t *testing.T) {
 	testTypeAssert(t, int(1111))
 	testTypeAssert(t, int(111111111))
 	testTypeAssert(t, int(-111111111))
@@ -8714,13 +8714,41 @@ func TestTypeAssert(t *testing.T) {
 	testTypeAssert(t, newPtr(111111111))
 	testTypeAssert(t, newPtr(-111111111))
 	testTypeAssert(t, newPtr([2]int{-111111111, -22222222}))
-
+	testTypeAssert(t, [2]*int{newPtr(-111111111), newPtr(-22222222)})
 	testTypeAssert(t, newPtr(time.Now()))
 
 	testTypeAssertDifferentType[uint](t, int(111111111))
 	testTypeAssertDifferentType[uint](t, int(-111111111))
 }
 
+func TestTypeAssertInterfaceTypes(t *testing.T) {
+	v, ok := TypeAssert[any](ValueOf(1))
+	if v != any(1) || !ok {
+		t.Errorf("TypeAssert[any](1) = (%v, %v); want = (1, true)", v, ok)
+	}
+
+	v, ok = TypeAssert[fmt.Stringer](ValueOf(1))
+	if v != nil || ok {
+		t.Errorf("TypeAssert[fmt.Stringer](1) = (%v, %v); want = (1, false)", v, ok)
+	}
+
+	v, ok = TypeAssert[any](ValueOf(testTypeWithMethod{"test"}))
+	if v != any(testTypeWithMethod{"test"}) || !ok {
+		t.Errorf(`TypeAssert[any](testTypeWithMethod{"test"}) = (%v, %v); want = (testTypeWithMethod{"test"}, true)`, v, ok)
+	}
+
+	v, ok = TypeAssert[fmt.Stringer](ValueOf(testTypeWithMethod{"test"}))
+	if v != fmt.Stringer(testTypeWithMethod{"test"}) || !ok {
+		t.Errorf(`TypeAssert[fmt.Stringer](testTypeWithMethod{"test"}) = (%v, %v); want = (testTypeWithMethod{"test"}, true)`, v, ok)
+	}
+
+	val := &testTypeWithMethod{"test"}
+	v, ok = TypeAssert[fmt.Stringer](ValueOf(val))
+	if v != fmt.Stringer(val) || !ok {
+		t.Errorf(`TypeAssert[fmt.Stringer](&testTypeWithMethod{"test"}) = (%v, %v); want = (&testTypeWithMethod{"test"}, true)`, v, ok)
+	}
+}
+
 type testTypeWithMethod struct {
 	val string
 }

src/reflect/value.go

@@ -1517,7 +1517,6 @@ func TypeAssert[T any](v Value) (T, bool) {
 	if v.flag == 0 {
 		panic(&ValueError{"reflect.TypeAssert", Invalid})
 	}
-
 	if v.flag&flagRO != 0 {
 		// Do not allow access to unexported values via Interface,
 		// because they might be pointers that should not be
@@ -1529,12 +1528,19 @@ func TypeAssert[T any](v Value) (T, bool) {
 		v = makeMethodValue("TypeAssert", v)
 	}
 
-	if abi.TypeFor[T]() != v.typ_ {
+	if abi.TypeFor[T]() != v.typ() {
+		// TypeAssert[T] should work the same way as v.Interface().(T), thus we need
+		// to handle following case properly: TypeAssert[any](ValueOf(1)).
+		// Note that we will not hit here is such case: TypeAssert[any](ValueOf(any(1))).
+		if abi.TypeFor[T]().Kind() == abi.Interface {
+			v, ok := packEface(v).(T)
+			return v, ok
+		}
 		var zero T
 		return zero, false
 	}
 
-	if v.typ_.IsDirectIface() {
+	if v.typ().IsDirectIface() {
 		return *(*T)(unsafe.Pointer(&v.ptr)), true
 	}