type I[T any] interface {
	m(T)
}

func f2[T any](func(I[T])) {}

func _() {
	var x func(interface{ m(int) })
	f2(x /* ERROR "type func(interface{m(int)}) of x does not match func(I[T]) (cannot infer T)" */)
}

func f3[T any](func(I[T])) {}

func _() {
	var x func(I[int])
	f3(x) // but this is correct: I[T] and I[int] can be made identical with T == int
}

func f4[T any]([10]I[T]) {}

func _() {

func (h *headerV7) name() []byte     { return h[000:][:100] }
func (h *headerV7) mode() []byte     { return h[100:][:8] }
func (h *headerV7) uid() []byte      { return h[108:][:8] }
func (h *headerV7) gid() []byte      { return h[116:][:8] }
func (h *headerV7) size() []byte     { return h[124:][:12] }
func (h *headerV7) modTime() []byte  { return h[136:][:12] }
func (h *headerV7) chksum() []byte   { return h[148:][:8] }

				t.done <- true
			}
		}
	}()

	doit := func(f func()) {
		done := make(chan bool, 1)
		select {
		case queue <- Task{f, done}:
		case <-dummy:
		}
		select {
		case <-done:
		case <-dummy:
		}
	}

	var x int
	doit(func() {
		x = 1
	})
	_ = x
}

func TestNoRaceSelect5(t *testing.T) {
	test := func(sel, needSched bool) {
		var x int
		_ = x

// expected-error@+1 {{expects function 'main' to have 1 block, got 2}}
func.func @main() {
  cf.br ^bb1
^bb1:
  func.return
}

// -----

// CHECK-LABEL: func @no_args
// CHECK-SAME: (%arg0: tensor<!tf_type.resource<tensor<f32>>> {tf.resource_name = "x"})
// CHECK-NOT: "tf.VarHandleOp"
func.func @no_args() {

		func() { o.object.SetGenerateName(name) },
	)
}
func (o *cachingObject) GetUID() types.UID {
	o.lock.RLock()
	defer o.lock.RUnlock()
	return o.object.GetUID()
}
func (o *cachingObject) SetUID(uid types.UID) {
	o.conditionalSet(
		func() bool { return o.object.GetUID() == uid },
		func() { o.object.SetUID(uid) },
	)
}
func (o *cachingObject) GetResourceVersion() string {

//go:nowritebarrierrec
func c1() {
	c2()
}

//go:yeswritebarrierrec
func c2() {
	c3()
}

func c3() {
	x.f = y
	c4()
}

//go:nowritebarrierrec
func c4() {
	c2()
}

//go:nowritebarrierrec
func d1() {
	d2()
}

func d2() {
	d3()
}

//go:noinline
func d3() {
	x.f = y // ERROR "write barrier prohibited by caller"
	d4()
}

// CHECK-LABEL: func @single_op_launch
func.func @single_op_launch() {
  // CHECK: "tf_device.launch"
  // CHECK: device = "CPU:0"
  // CHECK: "tf.opA"
  // CHECK-NOT device
  // CHECK: tf_device.return
  "tf.opA"() {device = "CPU:0"} : () -> tensor<i1>
  func.return
}

// Tests that usage of wrapped op is replaced by launch return
// CHECK-LABEL: func @launch_return

module {
  func.func @main() {
    %cst_main = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
    %0 = "tf.While"(%cst_main) {body = @while_body, cond = @while_cond, is_stateless = false} : (tensor<i32>) -> (tensor<i32>)
    return
  }
  func.func private @while_body(%arg0: tensor<i32>) -> (tensor<i32>) {

}

var _ ListInterface = &ListMeta{}

func (meta *ListMeta) GetResourceVersion() string        { return meta.ResourceVersion }
func (meta *ListMeta) SetResourceVersion(version string) { meta.ResourceVersion = version }
func (meta *ListMeta) GetSelfLink() string               { return meta.SelfLink }
func (meta *ListMeta) SetSelfLink(selfLink string)       { meta.SelfLink = selfLink }

	"testing"
)

type LogImpl struct {
	x int
}

func NewLog() (l LogImpl) {
	c := make(chan bool)
	go func() {
		_ = l
		c <- true
	}()
	l = LogImpl{}
	<-c
	return
}

var _ LogImpl = NewLog()

func MakeMap() map[int]int {
	return make(map[int]int)
}

func InstrumentMapLen() {
	_ = len(MakeMap())
}

func InstrumentMapLen2() {
	m := make(map[int]map[int]int)
	_ = len(m[0])