From: Dominique Lefevre <domingolefevre@gmail.com>
Date: Thu, 24 Aug 2023 07:17:36 +0000 (+0300)
Subject: cmd/link: add testcases for MethodByName(string literal).
X-Git-Tag: go1.22rc1~1015
X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=bb74a53c215a9e3ebf2c2b22bd60b06ce45f0b3b;p=gostls13.git

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 633a0d0bfb..6962a4eba0 100644
--- 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
index 0000000000..2f0bdcc745
--- /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
index 0000000000..7eb9419ef1
--- /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
index 0000000000..bec5f25fc0
--- /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})
+}