go issue51229 源码

  • 2022-07-15
  • 浏览 (506)

golang issue51229 代码

文件路径:/src/cmd/compile/internal/types2/testdata/fixedbugs/issue51229.go

// Copyright 2022 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.

package p

// Constraint type inference should be independent of the
// ordering of the type parameter declarations. Try all
// permutations in the test case below.
// Permutations produced by https://go.dev/play/p/PHcZNGJTEBZ.

func f00[S1 ~[]E1, S2 ~[]E2, E1 ~byte, E2 ~byte](S1, S2) {}
func f01[S2 ~[]E2, S1 ~[]E1, E1 ~byte, E2 ~byte](S1, S2) {}
func f02[E1 ~byte, S1 ~[]E1, S2 ~[]E2, E2 ~byte](S1, S2) {}
func f03[S1 ~[]E1, E1 ~byte, S2 ~[]E2, E2 ~byte](S1, S2) {}
func f04[S2 ~[]E2, E1 ~byte, S1 ~[]E1, E2 ~byte](S1, S2) {}
func f05[E1 ~byte, S2 ~[]E2, S1 ~[]E1, E2 ~byte](S1, S2) {}
func f06[E2 ~byte, S2 ~[]E2, S1 ~[]E1, E1 ~byte](S1, S2) {}
func f07[S2 ~[]E2, E2 ~byte, S1 ~[]E1, E1 ~byte](S1, S2) {}
func f08[S1 ~[]E1, E2 ~byte, S2 ~[]E2, E1 ~byte](S1, S2) {}
func f09[E2 ~byte, S1 ~[]E1, S2 ~[]E2, E1 ~byte](S1, S2) {}
func f10[S2 ~[]E2, S1 ~[]E1, E2 ~byte, E1 ~byte](S1, S2) {}
func f11[S1 ~[]E1, S2 ~[]E2, E2 ~byte, E1 ~byte](S1, S2) {}
func f12[S1 ~[]E1, E1 ~byte, E2 ~byte, S2 ~[]E2](S1, S2) {}
func f13[E1 ~byte, S1 ~[]E1, E2 ~byte, S2 ~[]E2](S1, S2) {}
func f14[E2 ~byte, S1 ~[]E1, E1 ~byte, S2 ~[]E2](S1, S2) {}
func f15[S1 ~[]E1, E2 ~byte, E1 ~byte, S2 ~[]E2](S1, S2) {}
func f16[E1 ~byte, E2 ~byte, S1 ~[]E1, S2 ~[]E2](S1, S2) {}
func f17[E2 ~byte, E1 ~byte, S1 ~[]E1, S2 ~[]E2](S1, S2) {}
func f18[E2 ~byte, E1 ~byte, S2 ~[]E2, S1 ~[]E1](S1, S2) {}
func f19[E1 ~byte, E2 ~byte, S2 ~[]E2, S1 ~[]E1](S1, S2) {}
func f20[S2 ~[]E2, E2 ~byte, E1 ~byte, S1 ~[]E1](S1, S2) {}
func f21[E2 ~byte, S2 ~[]E2, E1 ~byte, S1 ~[]E1](S1, S2) {}
func f22[E1 ~byte, S2 ~[]E2, E2 ~byte, S1 ~[]E1](S1, S2) {}
func f23[S2 ~[]E2, E1 ~byte, E2 ~byte, S1 ~[]E1](S1, S2) {}

type myByte byte

func _(a []byte, b []myByte) {
	f00(a, b)
	f01(a, b)
	f02(a, b)
	f03(a, b)
	f04(a, b)
	f05(a, b)
	f06(a, b)
	f07(a, b)
	f08(a, b)
	f09(a, b)
	f10(a, b)
	f11(a, b)
	f12(a, b)
	f13(a, b)
	f14(a, b)
	f15(a, b)
	f16(a, b)
	f17(a, b)
	f18(a, b)
	f19(a, b)
	f20(a, b)
	f21(a, b)
	f22(a, b)
	f23(a, b)
}

// Constraint type inference may have to iterate.
// Again, the order of the type parameters shouldn't matter.

func g0[S ~[]E, M ~map[string]S, E any](m M) {}
func g1[M ~map[string]S, S ~[]E, E any](m M) {}
func g2[E any, S ~[]E, M ~map[string]S](m M) {}
func g3[S ~[]E, E any, M ~map[string]S](m M) {}
func g4[M ~map[string]S, E any, S ~[]E](m M) {}
func g5[E any, M ~map[string]S, S ~[]E](m M) {}

func _(m map[string][]byte) {
	g0(m)
	g1(m)
	g2(m)
	g3(m)
	g4(m)
	g5(m)
}

// Worst-case scenario.
// There are 10 unknown type parameters. In each iteration of
// constraint type inference we infer one more, from right to left.
// Each iteration looks repeatedly at all 11 type parameters,
// requiring a total of 10*11 = 110 iterations with the current
// implementation. Pathological case.

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) {}

func _(x **********int) {
	h(x)
}

// Examples with channel constraints and tilde.

func ch1[P chan<- int]() (_ P)           { return } // core(P) == chan<- int   (single type, no tilde)
func ch2[P ~chan int]()                  { return } // core(P) == ~chan<- int  (tilde)
func ch3[P chan E, E any](E)             { return } // core(P) == chan<- E     (single type, no tilde)
func ch4[P chan E | ~chan<- E, E any](E) { return } // core(P) == ~chan<- E    (tilde)
func ch5[P chan int | chan<- int]()      { return } // core(P) == chan<- int   (not a single type)

func _() {
	// P can be inferred as there's a single specific type and no tilde.
	var _ chan int = ch1 /* ERROR cannot use ch1.*value of type chan<- int */ ()
	var _ chan<- int = ch1()

	// P cannot be inferred as there's a tilde.
	ch2( /* ERROR cannot infer P */ )
	type myChan chan int
	ch2[myChan]()

	// P can be inferred as there's a single specific type and no tilde.
	var e int
	ch3(e)

	// P cannot be inferred as there's more than one specific type and a tilde.
	ch4( /* ERROR cannot infer P */ e)
	_ = ch4[chan int]

	// P cannot be inferred as there's more than one specific type.
	ch5( /* ERROR cannot infer P */ )
	ch5[chan<- int]()
}

// test case from issue

func equal[M1 ~map[K1]V1, M2 ~map[K2]V2, K1, K2 ~uint32, V1, V2 ~string](m1 M1, m2 M2) bool {
	if len(m1) != len(m2) {
		return false
	}
	for k, v1 := range m1 {
		if v2, ok := m2[K2(k)]; !ok || V2(v1) != v2 {
			return false
		}
	}
	return true
}

func equalFixed[K1, K2 ~uint32, V1, V2 ~string](m1 map[K1]V1, m2 map[K2]V2) bool {
	if len(m1) != len(m2) {
		return false
	}
	for k, v1 := range m1 {
		if v2, ok := m2[K2(k)]; !ok || v1 != V1(v2) {
			return false
		}
	}
	return true
}

type (
	someNumericID uint32
	someStringID  string
)

func _() {
	foo := map[uint32]string{10: "bar"}
	bar := map[someNumericID]someStringID{10: "bar"}
	equal(foo, bar)
}

相关信息

go 源码目录

相关文章

go issue20583 源码

go issue23203a 源码

go issue23203b 源码

go issue25838 源码

go issue26390 源码

go issue28251 源码

go issue39634 源码

go issue39664 源码

go issue39680 源码

go issue39693 源码