methodset_test.go raw
1 // Copyright 2021 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 package types_test
6
7 import (
8 "slices"
9 "strings"
10 "testing"
11
12 "go/ast"
13 "go/parser"
14 "go/token"
15 . "go/types"
16 )
17
18 func TestNewMethodSet(t *testing.T) {
19 type method struct {
20 name string
21 index []int
22 indirect bool
23 }
24
25 // Tests are expressed src -> methods, for simplifying the composite literal.
26 // Should be kept in sync with TestLookupFieldOrMethod.
27 tests := map[string][]method{
28 // Named types
29 "var a T; type T struct{}; func (T) f() {}": {{"f", []int{0}, false}},
30 "var a *T; type T struct{}; func (T) f() {}": {{"f", []int{0}, true}},
31 "var a T; type T struct{}; func (*T) f() {}": {},
32 "var a *T; type T struct{}; func (*T) f() {}": {{"f", []int{0}, true}},
33
34 // Generic named types
35 "var a T[int]; type T[P any] struct{}; func (T[P]) f() {}": {{"f", []int{0}, false}},
36 "var a *T[int]; type T[P any] struct{}; func (T[P]) f() {}": {{"f", []int{0}, true}},
37 "var a T[int]; type T[P any] struct{}; func (*T[P]) f() {}": {},
38 "var a *T[int]; type T[P any] struct{}; func (*T[P]) f() {}": {{"f", []int{0}, true}},
39
40 // Interfaces
41 "var a T; type T interface{ f() }": {{"f", []int{0}, true}},
42 "var a T1; type ( T1 T2; T2 interface{ f() } )": {{"f", []int{0}, true}},
43 "var a T1; type ( T1 interface{ T2 }; T2 interface{ f() } )": {{"f", []int{0}, true}},
44
45 // Generic interfaces
46 "var a T[int]; type T[P any] interface{ f() }": {{"f", []int{0}, true}},
47 "var a T1[int]; type ( T1[P any] T2[P]; T2[P any] interface{ f() } )": {{"f", []int{0}, true}},
48 "var a T1[int]; type ( T1[P any] interface{ T2[P] }; T2[P any] interface{ f() } )": {{"f", []int{0}, true}},
49
50 // Embedding
51 "var a struct{ E }; type E interface{ f() }": {{"f", []int{0, 0}, true}},
52 "var a *struct{ E }; type E interface{ f() }": {{"f", []int{0, 0}, true}},
53 "var a struct{ E }; type E struct{}; func (E) f() {}": {{"f", []int{0, 0}, false}},
54 "var a struct{ *E }; type E struct{}; func (E) f() {}": {{"f", []int{0, 0}, true}},
55 "var a struct{ E }; type E struct{}; func (*E) f() {}": {},
56 "var a struct{ *E }; type E struct{}; func (*E) f() {}": {{"f", []int{0, 0}, true}},
57
58 // Embedding of generic types
59 "var a struct{ E[int] }; type E[P any] interface{ f() }": {{"f", []int{0, 0}, true}},
60 "var a *struct{ E[int] }; type E[P any] interface{ f() }": {{"f", []int{0, 0}, true}},
61 "var a struct{ E[int] }; type E[P any] struct{}; func (E[P]) f() {}": {{"f", []int{0, 0}, false}},
62 "var a struct{ *E[int] }; type E[P any] struct{}; func (E[P]) f() {}": {{"f", []int{0, 0}, true}},
63 "var a struct{ E[int] }; type E[P any] struct{}; func (*E[P]) f() {}": {},
64 "var a struct{ *E[int] }; type E[P any] struct{}; func (*E[P]) f() {}": {{"f", []int{0, 0}, true}},
65
66 // collisions
67 "var a struct{ E1; *E2 }; type ( E1 interface{ f() }; E2 struct{ f int })": {},
68 "var a struct{ E1; *E2 }; type ( E1 struct{ f int }; E2 struct{} ); func (E2) f() {}": {},
69
70 // recursive generic types; see go.dev/issue/52715
71 "var a T[int]; type ( T[P any] struct { *N[P] }; N[P any] struct { *T[P] } ); func (N[P]) m() {}": {{"m", []int{0, 0}, true}},
72 "var a T[int]; type ( T[P any] struct { *N[P] }; N[P any] struct { *T[P] } ); func (T[P]) m() {}": {{"m", []int{0}, false}},
73 }
74
75 tParamTests := map[string][]method{
76 // By convention, look up a in the scope of "g"
77 "type C interface{ f() }; func g[T C](a T){}": {{"f", []int{0}, true}},
78 "type C interface{ f() }; func g[T C]() { var a T; _ = a }": {{"f", []int{0}, true}},
79
80 // go.dev/issue/43621: We don't allow this anymore. Keep this code in case we
81 // decide to revisit this decision.
82 // "type C interface{ f() }; func g[T C]() { var a struct{T}; _ = a }": {{"f", []int{0, 0}, true}},
83
84 // go.dev/issue/45639: We also don't allow this anymore.
85 // "type C interface{ f() }; func g[T C]() { type Y T; var a Y; _ = a }": {},
86 }
87
88 check := func(src string, methods []method, generic bool) {
89 pkg := mustTypecheck("package p;"+src, nil, nil)
90
91 scope := pkg.Scope()
92 if generic {
93 fn := pkg.Scope().Lookup("g").(*Func)
94 scope = fn.Scope()
95 }
96 obj := scope.Lookup("a")
97 if obj == nil {
98 t.Errorf("%s: incorrect test case - no object a", src)
99 return
100 }
101
102 ms := NewMethodSet(obj.Type())
103 if got, want := ms.Len(), len(methods); got != want {
104 t.Errorf("%s: got %d methods, want %d", src, got, want)
105 return
106 }
107 for i, m := range methods {
108 sel := ms.At(i)
109 if got, want := sel.Obj().Name(), m.name; got != want {
110 t.Errorf("%s [method %d]: got name = %q at, want %q", src, i, got, want)
111 }
112 if got, want := sel.Index(), m.index; !slices.Equal(got, want) {
113 t.Errorf("%s [method %d]: got index = %v, want %v", src, i, got, want)
114 }
115 if got, want := sel.Indirect(), m.indirect; got != want {
116 t.Errorf("%s [method %d]: got indirect = %v, want %v", src, i, got, want)
117 }
118 }
119 }
120
121 for src, methods := range tests {
122 check(src, methods, false)
123 }
124
125 for src, methods := range tParamTests {
126 check(src, methods, true)
127 }
128 }
129
130 // Test for go.dev/issue/52715
131 func TestNewMethodSet_RecursiveGeneric(t *testing.T) {
132 const src = `
133 package pkg
134
135 type Tree[T any] struct {
136 *Node[T]
137 }
138
139 type Node[T any] struct {
140 *Tree[T]
141 }
142
143 type Instance = *Tree[int]
144 `
145
146 fset := token.NewFileSet()
147 f, err := parser.ParseFile(fset, "foo.go", src, 0)
148 if err != nil {
149 panic(err)
150 }
151 pkg := NewPackage("pkg", f.Name.Name)
152 if err := NewChecker(nil, fset, pkg, nil).Files([]*ast.File{f}); err != nil {
153 panic(err)
154 }
155
156 T := pkg.Scope().Lookup("Instance").Type()
157 _ = NewMethodSet(T) // verify that NewMethodSet terminates
158 }
159
160 func TestIssue60634(t *testing.T) {
161 const src = `
162 package p
163 type T *int
164 func (T) m() {} // expected error: invalid receiver type
165 `
166
167 fset := token.NewFileSet()
168 f, err := parser.ParseFile(fset, "p.go", src, 0)
169 if err != nil {
170 t.Fatal(err)
171 }
172
173 var conf Config
174 pkg, err := conf.Check("p", fset, []*ast.File{f}, nil)
175 if err == nil || !strings.Contains(err.Error(), "invalid receiver type") {
176 t.Fatalf("missing or unexpected error: %v", err)
177 }
178
179 // look up T.m and (*T).m
180 T := pkg.Scope().Lookup("T").Type()
181 name := "m"
182 for _, recv := range []Type{T, NewPointer(T)} {
183 // LookupFieldOrMethod and NewMethodSet must match:
184 // either both find m or neither finds it.
185 obj1, _, _ := LookupFieldOrMethod(recv, false, pkg, name)
186 mset := NewMethodSet(recv)
187 if (obj1 != nil) != (mset.Len() == 1) {
188 t.Fatalf("lookup(%v.%s): got obj = %v, mset = %v", recv, name, obj1, mset)
189 }
190 // If the method exists, both must return the same object.
191 if obj1 != nil {
192 obj2 := mset.At(0).Obj()
193 if obj1 != obj2 {
194 t.Fatalf("%v != %v", obj1, obj2)
195 }
196 }
197 }
198 }
199