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>

2 files changed, 35 insertions, 51 deletions

diff --git a/src/reflect/type.go b/src/reflect/type.go
index 4254c657d2..d6744c2898 100644
--- 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 75784f9666..9e124273a2 100644
--- 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()
+	})
+}