1 // Copyright 2022 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 p
6
7 // Constraint type inference should be independent of the
8 // ordering of the type parameter declarations. Try all
9 // permutations in the test case below.
10 // Permutations produced by https://go.dev/play/p/PHcZNGJTEBZ.
11
12 func f00[S1 ~[]E1, S2 ~[]E2, E1 ~byte, E2 ~byte](S1, S2) {}
13 func f01[S2 ~[]E2, S1 ~[]E1, E1 ~byte, E2 ~byte](S1, S2) {}
14 func f02[E1 ~byte, S1 ~[]E1, S2 ~[]E2, E2 ~byte](S1, S2) {}
15 func f03[S1 ~[]E1, E1 ~byte, S2 ~[]E2, E2 ~byte](S1, S2) {}
16 func f04[S2 ~[]E2, E1 ~byte, S1 ~[]E1, E2 ~byte](S1, S2) {}
17 func f05[E1 ~byte, S2 ~[]E2, S1 ~[]E1, E2 ~byte](S1, S2) {}
18 func f06[E2 ~byte, S2 ~[]E2, S1 ~[]E1, E1 ~byte](S1, S2) {}
19 func f07[S2 ~[]E2, E2 ~byte, S1 ~[]E1, E1 ~byte](S1, S2) {}
20 func f08[S1 ~[]E1, E2 ~byte, S2 ~[]E2, E1 ~byte](S1, S2) {}
21 func f09[E2 ~byte, S1 ~[]E1, S2 ~[]E2, E1 ~byte](S1, S2) {}
22 func f10[S2 ~[]E2, S1 ~[]E1, E2 ~byte, E1 ~byte](S1, S2) {}
23 func f11[S1 ~[]E1, S2 ~[]E2, E2 ~byte, E1 ~byte](S1, S2) {}
24 func f12[S1 ~[]E1, E1 ~byte, E2 ~byte, S2 ~[]E2](S1, S2) {}
25 func f13[E1 ~byte, S1 ~[]E1, E2 ~byte, S2 ~[]E2](S1, S2) {}
26 func f14[E2 ~byte, S1 ~[]E1, E1 ~byte, S2 ~[]E2](S1, S2) {}
27 func f15[S1 ~[]E1, E2 ~byte, E1 ~byte, S2 ~[]E2](S1, S2) {}
28 func f16[E1 ~byte, E2 ~byte, S1 ~[]E1, S2 ~[]E2](S1, S2) {}
29 func f17[E2 ~byte, E1 ~byte, S1 ~[]E1, S2 ~[]E2](S1, S2) {}
30 func f18[E2 ~byte, E1 ~byte, S2 ~[]E2, S1 ~[]E1](S1, S2) {}
31 func f19[E1 ~byte, E2 ~byte, S2 ~[]E2, S1 ~[]E1](S1, S2) {}
32 func f20[S2 ~[]E2, E2 ~byte, E1 ~byte, S1 ~[]E1](S1, S2) {}
33 func f21[E2 ~byte, S2 ~[]E2, E1 ~byte, S1 ~[]E1](S1, S2) {}
34 func f22[E1 ~byte, S2 ~[]E2, E2 ~byte, S1 ~[]E1](S1, S2) {}
35 func f23[S2 ~[]E2, E1 ~byte, E2 ~byte, S1 ~[]E1](S1, S2) {}
36
37 type myByte byte
38
39 func _(a []byte, b []myByte) {
40 f00(a, b)
41 f01(a, b)
42 f02(a, b)
43 f03(a, b)
44 f04(a, b)
45 f05(a, b)
46 f06(a, b)
47 f07(a, b)
48 f08(a, b)
49 f09(a, b)
50 f10(a, b)
51 f11(a, b)
52 f12(a, b)
53 f13(a, b)
54 f14(a, b)
55 f15(a, b)
56 f16(a, b)
57 f17(a, b)
58 f18(a, b)
59 f19(a, b)
60 f20(a, b)
61 f21(a, b)
62 f22(a, b)
63 f23(a, b)
64 }
65
66 // Constraint type inference may have to iterate.
67 // Again, the order of the type parameters shouldn't matter.
68
69 func g0[S ~[]E, M ~map[string]S, E any](m M) {}
70 func g1[M ~map[string]S, S ~[]E, E any](m M) {}
71 func g2[E any, S ~[]E, M ~map[string]S](m M) {}
72 func g3[S ~[]E, E any, M ~map[string]S](m M) {}
73 func g4[M ~map[string]S, E any, S ~[]E](m M) {}
74 func g5[E any, M ~map[string]S, S ~[]E](m M) {}
75
76 func _(m map[string][]byte) {
77 g0(m)
78 g1(m)
79 g2(m)
80 g3(m)
81 g4(m)
82 g5(m)
83 }
84
85 // Worst-case scenario.
86 // There are 10 unknown type parameters. In each iteration of
87 // constraint type inference we infer one more, from right to left.
88 // Each iteration looks repeatedly at all 11 type parameters,
89 // requiring a total of 10*11 = 110 iterations with the current
90 // implementation. Pathological case.
91
92 func h[K any, J ~*K, I ~*J, H ~*I, G ~*H, F ~*G, E ~*F, D ~*E, C ~*D, B ~*C, A ~*B](x A) {}
93
94 func _(x **********int) {
95 h(x)
96 }
97
98 // Examples with channel constraints and tilde.
99
100 func ch1[P chan<- int]() (_ P) { return } // core(P) == chan<- int (single type, no tilde)
101 func ch2[P ~chan int]() { return } // core(P) == ~chan<- int (tilde)
102 func ch3[P chan E, E any](E) { return } // core(P) == chan<- E (single type, no tilde)
103 func ch4[P chan E | ~chan<- E, E any](E) { return } // core(P) == ~chan<- E (tilde)
104 func ch5[P chan int | chan<- int]() { return } // core(P) == chan<- int (not a single type)
105
106 func _() {
107 // P can be inferred as there's a single specific type and no tilde.
108 var _ chan int = ch1 /* ERROR cannot use ch1.*value of type chan<- int */ ()
109 var _ chan<- int = ch1()
110
111 // P cannot be inferred as there's a tilde.
112 ch2 /* ERROR cannot infer P */ ()
113 type myChan chan int
114 ch2[myChan]()
115
116 // P can be inferred as there's a single specific type and no tilde.
117 var e int
118 ch3(e)
119
120 // P cannot be inferred as there's more than one specific type and a tilde.
121 ch4 /* ERROR cannot infer P */ (e)
122 _ = ch4[chan int]
123
124 // P cannot be inferred as there's more than one specific type.
125 ch5 /* ERROR cannot infer P */ ()
126 ch5[chan<- int]()
127 }
128
129 // test case from issue
130
131 func equal[M1 ~map[K1]V1, M2 ~map[K2]V2, K1, K2 ~uint32, V1, V2 ~string](m1 M1, m2 M2) bool {
132 if len(m1) != len(m2) {
133 return false
134 }
135 for k, v1 := range m1 {
136 if v2, ok := m2[K2(k)]; !ok || V2(v1) != v2 {
137 return false
138 }
139 }
140 return true
141 }
142
143 func equalFixed[K1, K2 ~uint32, V1, V2 ~string](m1 map[K1]V1, m2 map[K2]V2) bool {
144 if len(m1) != len(m2) {
145 return false
146 }
147 for k, v1 := range m1 {
148 if v2, ok := m2[K2(k)]; !ok || v1 != V1(v2) {
149 return false
150 }
151 }
152 return true
153 }
154
155 type (
156 someNumericID uint32
157 someStringID string
158 )
159
160 func _() {
161 foo := map[uint32]string{10: "bar"}
162 bar := map[someNumericID]someStringID{10: "bar"}
163 equal(foo, bar)
164 }
165
View as plain text