qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-10-01 01:18:32 -06:00
Code Releases Activity

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

Browse Source 
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>
This commit is contained in:
Dominique Lefevre 2023-09-06 15:58:13 +03:00 committed by Cherry Mui
parent 9b883484a8
commit 6d5c9f2f26
3 changed files with 35 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/cmd/compile/internal/walk/expr.go
View File

@ -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
}
}

62
src/reflect/type.go
View File

@ -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.

24
src/reflect/type_test.go
View File

@ -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()
})
}