cmd/link: add testcases for MethodByName(string literal).

Change-Id: I96ea268ecceea75a24303526ed2f17c8a5e142c1
Reviewed-on: https://go-review.googlesource.com/c/go/+/522438
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Run-TryBot: Cherry Mui <cherryyz@google.com>

diff --git a/src/cmd/link/internal/ld/deadcode_test.go b/src/cmd/link/internal/ld/deadcode_test.go
index 633a0d0bfb1cee6d24744745c98cf1e1e82569a8..6962a4eba01195247ff3138ddec1c23d855d684a 100644 (file)
--- a/src/cmd/link/internal/ld/deadcode_test.go
+++ b/src/cmd/link/internal/ld/deadcode_test.go
@@ -27,6 +27,9 @@ func TestDeadcode(t *testing.T) {
                {"ifacemethod2", []string{"main.T.M"}, nil},
                {"ifacemethod3", []string{"main.S.M"}, nil},
                {"ifacemethod4", nil, []string{"main.T.M"}},
+               {"ifacemethod5", []string{"main.S.M"}, nil},
+               {"ifacemethod6", []string{"main.S.M"}, []string{"main.S.N"}},
+               {"structof_funcof", []string{"main.S.M"}, []string{"main.S.N"}},
                {"globalmap", []string{"main.small", "main.effect"},
                        []string{"main.large"}},
        }

diff --git a/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod5.go b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod5.go
new file mode 100644 (file)
index 0000000..2f0bdcc
--- /dev/null
+++ b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod5.go
@@ -0,0 +1,33 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Like ifacemethod2.go, this tests that a method *is* live
+// if the type is "indirectly" converted to an interface
+// using reflection with a method descriptor as intermediate.
+// However, it uses MethodByName() with a constant name of
+// a method to look up. This does not disable the DCE like
+// Method(0) does.
+
+package main
+
+import "reflect"
+
+type S int
+
+func (s S) M() { println("S.M") }
+
+type I interface{ M() }
+
+type T float64
+
+func (t T) F(s S) {}
+
+func main() {
+       var t T
+       meth, _ := reflect.TypeOf(t).MethodByName("F")
+       ft := meth.Type
+       at := ft.In(1)
+       v := reflect.New(at).Elem()
+       v.Interface().(I).M()
+}

diff --git a/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod6.go b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod6.go
new file mode 100644 (file)
index 0000000..7eb9419
--- /dev/null
+++ b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod6.go
@@ -0,0 +1,31 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This test only uses MethodByName() with constant names
+// of methods to look up. These methods need to be kept,
+// but other methods must be eliminated.
+
+package main
+
+import "reflect"
+
+type S int
+
+func (s S) M() { println("S.M") }
+
+func (s S) N() { println("S.N") }
+
+type T float64
+
+func (t T) F(s S) {}
+
+func main() {
+       var t T
+       meth, _ := reflect.TypeOf(t).MethodByName("F")
+       ft := meth.Type
+       at := ft.In(1)
+       v := reflect.New(at).Elem()
+       methV := v.MethodByName("M")
+       methV.Call([]reflect.Value{v})
+}

diff --git a/src/cmd/link/internal/ld/testdata/deadcode/structof_funcof.go b/src/cmd/link/internal/ld/testdata/deadcode/structof_funcof.go
new file mode 100644 (file)
index 0000000..bec5f25
--- /dev/null
+++ b/src/cmd/link/internal/ld/testdata/deadcode/structof_funcof.go
@@ -0,0 +1,52 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Methods of reflect.rtype use StructOf and FuncOf which in turn depend on
+// reflect.Value.Method. StructOf and FuncOf must not disable the DCE.
+
+package main
+
+import "reflect"
+
+type S int
+
+func (s S) M() { println("S.M") }
+
+func (s S) N() { println("S.N") }
+
+type T float64
+
+func (t T) F(s S) {}
+
+func useStructOf() {
+       t := reflect.StructOf([]reflect.StructField{
+               {
+                       Name: "X",
+                       Type: reflect.TypeOf(int(0)),
+               },
+       })
+       println(t.Name())
+}
+
+func useFuncOf() {
+       t := reflect.FuncOf(
+               []reflect.Type{reflect.TypeOf(int(0))},
+               []reflect.Type{reflect.TypeOf(int(0))},
+               false,
+       )
+       println(t.Name())
+}
+
+func main() {
+       useStructOf()
+       useFuncOf()
+
+       var t T
+       meth, _ := reflect.TypeOf(t).MethodByName("F")
+       ft := meth.Type
+       at := ft.In(1)
+       v := reflect.New(at).Elem()
+       methV := v.MethodByName("M")
+       methV.Call([]reflect.Value{v})
+}