instantiate_test.go raw
1 // Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
2 // Source: ../../cmd/compile/internal/types2/instantiate_test.go
3
4 // Copyright 2021 The Go Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style
6 // license that can be found in the LICENSE file.
7 package types_test
8
9 import (
10 . "go/types"
11 "strings"
12 "testing"
13 )
14
15 func TestInstantiateEquality(t *testing.T) {
16 emptySignature := NewSignatureType(nil, nil, nil, nil, nil, false)
17 tests := []struct {
18 src string
19 name1 string
20 targs1 []Type
21 name2 string
22 targs2 []Type
23 wantEqual bool
24 }{
25 {
26 "package basictype; type T[P any] int",
27 "T", []Type{Typ[Int]},
28 "T", []Type{Typ[Int]},
29 true,
30 },
31 {
32 "package differenttypeargs; type T[P any] int",
33 "T", []Type{Typ[Int]},
34 "T", []Type{Typ[String]},
35 false,
36 },
37 {
38 "package typeslice; type T[P any] int",
39 "T", []Type{NewSlice(Typ[Int])},
40 "T", []Type{NewSlice(Typ[Int])},
41 true,
42 },
43 {
44 // interface{interface{...}} is equivalent to interface{...}
45 "package equivalentinterfaces; type T[P any] int",
46 "T", []Type{
47 NewInterfaceType([]*Func{NewFunc(nopos, nil, "M", emptySignature)}, nil),
48 },
49 "T", []Type{
50 NewInterfaceType(
51 nil,
52 []Type{
53 NewInterfaceType([]*Func{NewFunc(nopos, nil, "M", emptySignature)}, nil),
54 },
55 ),
56 },
57 true,
58 },
59 {
60 // int|string is equivalent to string|int
61 "package equivalenttypesets; type T[P any] int",
62 "T", []Type{
63 NewInterfaceType(nil, []Type{
64 NewUnion([]*Term{NewTerm(false, Typ[Int]), NewTerm(false, Typ[String])}),
65 }),
66 },
67 "T", []Type{
68 NewInterfaceType(nil, []Type{
69 NewUnion([]*Term{NewTerm(false, Typ[String]), NewTerm(false, Typ[Int])}),
70 }),
71 },
72 true,
73 },
74 {
75 "package basicfunc; func F[P any]() {}",
76 "F", []Type{Typ[Int]},
77 "F", []Type{Typ[Int]},
78 true,
79 },
80 {
81 "package funcslice; func F[P any]() {}",
82 "F", []Type{NewSlice(Typ[Int])},
83 "F", []Type{NewSlice(Typ[Int])},
84 true,
85 },
86 {
87 "package funcwithparams; func F[P any](x string) float64 { return 0 }",
88 "F", []Type{Typ[Int]},
89 "F", []Type{Typ[Int]},
90 true,
91 },
92 {
93 "package differentfuncargs; func F[P any](x string) float64 { return 0 }",
94 "F", []Type{Typ[Int]},
95 "F", []Type{Typ[String]},
96 false,
97 },
98 {
99 "package funcequality; func F1[P any](x int) {}; func F2[Q any](x int) {}",
100 "F1", []Type{Typ[Int]},
101 "F2", []Type{Typ[Int]},
102 false,
103 },
104 {
105 "package funcsymmetry; func F1[P any](x P) {}; func F2[Q any](x Q) {}",
106 "F1", []Type{Typ[Int]},
107 "F2", []Type{Typ[Int]},
108 false,
109 },
110 }
111
112 for _, test := range tests {
113 pkg := mustTypecheck(test.src, nil, nil)
114
115 t.Run(pkg.Name(), func(t *testing.T) {
116 ctxt := NewContext()
117
118 T1 := pkg.Scope().Lookup(test.name1).Type()
119 res1, err := Instantiate(ctxt, T1, test.targs1, false)
120 if err != nil {
121 t.Fatal(err)
122 }
123
124 T2 := pkg.Scope().Lookup(test.name2).Type()
125 res2, err := Instantiate(ctxt, T2, test.targs2, false)
126 if err != nil {
127 t.Fatal(err)
128 }
129
130 if gotEqual := res1 == res2; gotEqual != test.wantEqual {
131 t.Errorf("%s == %s: %t, want %t", res1, res2, gotEqual, test.wantEqual)
132 }
133 })
134 }
135 }
136
137 func TestInstantiateNonEquality(t *testing.T) {
138 const src = "package p; type T[P any] int"
139 pkg1 := mustTypecheck(src, nil, nil)
140 pkg2 := mustTypecheck(src, nil, nil)
141 // We consider T1 and T2 to be distinct types, so their instances should not
142 // be deduplicated by the context.
143 T1 := pkg1.Scope().Lookup("T").Type().(*Named)
144 T2 := pkg2.Scope().Lookup("T").Type().(*Named)
145 ctxt := NewContext()
146 res1, err := Instantiate(ctxt, T1, []Type{Typ[Int]}, false)
147 if err != nil {
148 t.Fatal(err)
149 }
150 res2, err := Instantiate(ctxt, T2, []Type{Typ[Int]}, false)
151 if err != nil {
152 t.Fatal(err)
153 }
154 if res1 == res2 {
155 t.Errorf("instance from pkg1 (%s) is pointer-equivalent to instance from pkg2 (%s)", res1, res2)
156 }
157 if Identical(res1, res2) {
158 t.Errorf("instance from pkg1 (%s) is identical to instance from pkg2 (%s)", res1, res2)
159 }
160 }
161
162 func TestMethodInstantiation(t *testing.T) {
163 const prefix = `package p
164
165 type T[P any] struct{}
166
167 var X T[int]
168
169 `
170 tests := []struct {
171 decl string
172 want string
173 }{
174 {"func (r T[P]) m() P", "func (T[int]).m() int"},
175 {"func (r T[P]) m(P)", "func (T[int]).m(int)"},
176 {"func (r *T[P]) m(P)", "func (*T[int]).m(int)"},
177 {"func (r T[P]) m() T[P]", "func (T[int]).m() T[int]"},
178 {"func (r T[P]) m(T[P])", "func (T[int]).m(T[int])"},
179 {"func (r T[P]) m(T[P], P, string)", "func (T[int]).m(T[int], int, string)"},
180 {"func (r T[P]) m(T[P], T[string], T[int])", "func (T[int]).m(T[int], T[string], T[int])"},
181 }
182
183 for _, test := range tests {
184 src := prefix + test.decl
185 pkg := mustTypecheck(src, nil, nil)
186 typ := NewPointer(pkg.Scope().Lookup("X").Type())
187 sel, ok := LookupSelection(typ, false, pkg, "m")
188 if !ok {
189 t.Fatalf(`LookupSelection(%s, "m") failed, want func m`, typ)
190 }
191 if got := ObjectString(sel.Obj(), RelativeTo(pkg)); got != test.want {
192 t.Errorf("instantiated %q, want %q", got, test.want)
193 }
194 }
195 }
196
197 func TestImmutableSignatures(t *testing.T) {
198 const src = `package p
199
200 type T[P any] struct{}
201
202 func (T[P]) m() {}
203
204 var _ T[int]
205 `
206 pkg := mustTypecheck(src, nil, nil)
207 typ := pkg.Scope().Lookup("T").Type().(*Named)
208 sel, ok := LookupSelection(typ, false, pkg, "m")
209 if !ok {
210 t.Fatalf(`LookupSelection(%s, "m") failed, want func m`, typ)
211 }
212
213 // Verify that the original method is not mutated by instantiating T (this
214 // bug manifested when subst did not return a new signature).
215 want := "func (T[P]).m()"
216 if got := stripAnnotations(ObjectString(sel.Obj(), RelativeTo(pkg))); got != want {
217 t.Errorf("instantiated %q, want %q", got, want)
218 }
219 }
220
221 // Copied from errors.go.
222 func stripAnnotations(s string) string {
223 var buf strings.Builder
224 for _, r := range s {
225 // strip #'s and subscript digits
226 if r < '₀' || '₀'+10 <= r { // '₀' == U+2080
227 buf.WriteRune(r)
228 }
229 }
230 if buf.Len() < len(s) {
231 return buf.String()
232 }
233 return s
234 }
235