reflect: remove broken support for embedding of interfaces from StructOf.

When reviewing https://go-review.googlesource.com/c/go/+/522435,
Cherry Mui cherryyz@google.com noticed that the implementation of
StructOf was broken, and produced junk if an interface was embedded
into a struct. For example, StructOf messed up the calling convention
for methods of the embedded interface:

> The main problem is that the method wrappers created by reflect.MakeFunc
> expects to be called with a closure calling convention, with a closure
> context passed in the context register. But methods are called with
> a different calling convention, without setting the closure register,
> because (besides this case) all methods are top level functions.
> So there is no way to pass that makefunc closure context.

It is curious that StructOf did not break in go 1.17 which introduced
the regabi. I've tried to run the following example program, and it
fails even in 1.7 which introduced StructOf.

As the embedding of interfaces has been broken since forever,
let us not perpetuate the complexity that this feature brings,
and just remove the support for embedding altogether.

The test program:

package main

import (
	"fmt"
	"reflect"
)

type I interface {
	F()
}

type T int

func (t T) F() { println(t) }

func main() {
	var i I
	t := reflect.StructOf([]reflect.StructField{
		{
			Anonymous: true,
			Name:      "I",
			Type:      reflect.TypeOf(&i).Elem(),
		},
	})
	v := reflect.New(t).Elem()
	v.Field(0).Set(reflect.ValueOf(T(42)))
	fmt.Println(v)
	v.Interface().(interface{ F() }).F() // fatal error
}

Change-Id: I7b2115c22d66ea4ed746f0f9d22b2c94f604e185
Reviewed-on: https://go-review.googlesource.com/c/go/+/526075
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index d3557d2f942779e46cec3627f10975c9da9961ac..f033d66884616e678e89632f25288d9742edf135 100644 (file)
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -968,16 +968,6 @@ func usemethod(n *ir.CallExpr) {
                        return
                case fn == "Value.Method", fn == "Value.MethodByName":
                        return
-               // StructOf defines closures that look up methods. They only look up methods
-               // reachable via interfaces. The DCE does not remove such methods. It is ok
-               // to not flag closures in StructOf as ReflectMethods and let the DCE run
-               // even if StructOf is reachable.
-               //
-               // (*rtype).MethodByName calls into StructOf so flagging StructOf as
-               // ReflectMethod would disable the DCE even when the name of a method
-               // to look up is a compile-time constant.
-               case strings.HasPrefix(fn, "StructOf.func"):
-                       return
                }
        }
 

diff --git a/src/reflect/type.go b/src/reflect/type.go
index 4254c657d2d8bd32002cb8bc465f8620d472375f..d6744c2898f804c0da69f76c47946eecc53e9a0e 100644 (file)
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -2156,9 +2156,8 @@ func isValidFieldName(fieldName string) bool {
 // The Offset and Index fields are ignored and computed as they would be
 // by the compiler.
 //
-// StructOf currently does not generate wrapper methods for embedded
-// fields and panics if passed unexported StructFields.
-// These limitations may be lifted in a future version.
+// StructOf currently does not support promoted methods of embedded fields
+// and panics if passed unexported StructFields.
 func StructOf(fields []StructField) Type {
        var (
                hash       = fnv1(0, []byte("struct {")...)
@@ -2217,61 +2216,18 @@ func StructOf(fields []StructField) Type {
                        switch Kind(f.Typ.Kind()) {
                        case Interface:
                                ift := (*interfaceType)(unsafe.Pointer(ft))
-                               for im, m := range ift.Methods {
+                               for _, m := range ift.Methods {
                                        if pkgPath(ift.nameOff(m.Name)) != "" {
                                                // TODO(sbinet).  Issue 15924.
                                                panic("reflect: embedded interface with unexported method(s) not implemented")
                                        }
 
-                                       var (
-                                               mtyp    = ift.typeOff(m.Typ)
-                                               ifield  = i
-                                               imethod = im
-                                               ifn     Value
-                                               tfn     Value
-                                       )
-
-                                       if ft.Kind_&kindDirectIface != 0 {
-                                               tfn = MakeFunc(toRType(mtyp), func(in []Value) []Value {
-                                                       var args []Value
-                                                       var recv = in[0]
-                                                       if len(in) > 1 {
-                                                               args = in[1:]
-                                                       }
-                                                       return recv.Field(ifield).Method(imethod).Call(args)
-                                               })
-                                               ifn = MakeFunc(toRType(mtyp), func(in []Value) []Value {
-                                                       var args []Value
-                                                       var recv = in[0]
-                                                       if len(in) > 1 {
-                                                               args = in[1:]
-                                                       }
-                                                       return recv.Field(ifield).Method(imethod).Call(args)
-                                               })
-                                       } else {
-                                               tfn = MakeFunc(toRType(mtyp), func(in []Value) []Value {
-                                                       var args []Value
-                                                       var recv = in[0]
-                                                       if len(in) > 1 {
-                                                               args = in[1:]
-                                                       }
-                                                       return recv.Field(ifield).Method(imethod).Call(args)
-                                               })
-                                               ifn = MakeFunc(toRType(mtyp), func(in []Value) []Value {
-                                                       var args []Value
-                                                       var recv = Indirect(in[0])
-                                                       if len(in) > 1 {
-                                                               args = in[1:]
-                                                       }
-                                                       return recv.Field(ifield).Method(imethod).Call(args)
-                                               })
-                                       }
-
+                                       fnStub := resolveReflectText(unsafe.Pointer(abi.FuncPCABIInternal(embeddedIfaceMethStub)))
                                        methods = append(methods, abi.Method{
                                                Name: resolveReflectName(ift.nameOff(m.Name)),
-                                               Mtyp: resolveReflectType(mtyp),
-                                               Ifn:  resolveReflectText(unsafe.Pointer(&ifn)),
-                                               Tfn:  resolveReflectText(unsafe.Pointer(&tfn)),
+                                               Mtyp: resolveReflectType(ift.typeOff(m.Typ)),
+                                               Ifn:  fnStub,
+                                               Tfn:  fnStub,
                                        })
                                }
                        case Pointer:
@@ -2570,6 +2526,10 @@ func StructOf(fields []StructField) Type {
        return addToCache(toType(&typ.Type))
 }
 
+func embeddedIfaceMethStub() {
+       panic("reflect: StructOf does not support methods of embedded interfaces")
+}
+
 // runtimeStructField takes a StructField value passed to StructOf and
 // returns both the corresponding internal representation, of type
 // structField, and the pkgpath value to use for this field.

diff --git a/src/reflect/type_test.go b/src/reflect/type_test.go
index 75784f96665063f4f46a78878b9b1b3389bae5e9..9e124273a2e0b50320e06f27162f941c695b9105 100644 (file)
--- a/src/reflect/type_test.go
+++ b/src/reflect/type_test.go
@@ -33,3 +33,27 @@ func TestTypeFor(t *testing.T) {
                }
        }
 }
+
+func TestStructOfEmbeddedIfaceMethodCall(t *testing.T) {
+       type Named interface {
+               Name() string
+       }
+
+       typ := reflect.StructOf([]reflect.StructField{
+               {
+                       Anonymous: true,
+                       Name:      "Named",
+                       Type:      reflect.TypeFor[Named](),
+               },
+       })
+
+       v := reflect.New(typ).Elem()
+       v.Field(0).Set(
+               reflect.ValueOf(reflect.TypeFor[string]()),
+       )
+
+       x := v.Interface().(Named)
+       shouldPanic("StructOf does not support methods of embedded interfaces", func() {
+               _ = x.Name()
+       })
+}