fooer 6
other
other

// license that can be found in the LICENSE file.

package main

type Fooer interface {
	Foo() Barer
}

type Barer interface {
	Bar()
}

type impl struct{}

func (r *impl) Foo() Barer {
	return r
}

func (r *impl) Bar() {}

func f1() {
	var r Fooer = &impl{}
	r.Foo().Bar()

	var t T

	if i != t {
		println("FAIL: if i != t")
	}
}

type myint int

func (m myint) foo() {
}

type fooer interface {
	foo()
}

type comparableFoo interface {
	comparable
	foo()
}

func g[T comparableFoo](i fooer) {
	var t T

	if i != t {
		println("FAIL: if i != t")
	}
}

func main() {
	f[int](int(0))
	g[myint](myint(0))

// license that can be found in the LICENSE file.

package p

type Fooer interface {
	Foo()
}

type Fooable[F /* ERROR "instantiation cycle" */ Fooer] struct {
	ptr F
}

func (f *Fooable[F]) Adapter() *Fooable[*FooerImpl[F]] {
	return &Fooable[*FooerImpl[F]]{&FooerImpl[F]{}}
}

type FooerImpl[F Fooer] struct {
}

package main

func main() {
	Gooer2[byte]()
}

type Fooer[T any] interface {
	Foo(p T)
}

type fooer1[T any] struct{}

func (fooer1[T]) Foo(T) {}

type fooer2[T any] struct {
	r []Fooer[T]
}

//go:noinline
func (mr fooer2[T]) Foo(p T) {
	mr.r[0] = fooer1[T]{}
	return
}

func Gooer2[T any]() Fooer[T] {
	return fooer2[T]{}

	}
}

// Test that escape analysis correctly tracks escaping inside of methods
// called on generic types.
type fooer interface {
	foo()
}
type P struct {
	p *int
	q int
}

var esc []*int

func (p P) foo() {
	esc = append(esc, p.p) // foo escapes the pointer from inside of p
}
func f[T fooer](t T) {
	t.foo()
}
func TestGenericEscape(t *testing.T) {
	for i := 0; i < 4; i++ {
		var x int = 77 + i

	switch t {
	case i:
		// ok
	default:
		println("FAIL: switch t")
	}
}

type myint int

func (m myint) foo() {
}

type fooer interface {
	foo()
}

type comparableFoo interface {
	comparable
	foo()
}

func g[T comparableFoo](i fooer) {
	var t T

	switch i {
	case t:
		// ok
	default:
		println("FAIL: switch i")
	}

	switch t {
	case i:
		// ok
	default:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type Fooer[t any] interface {
	foo(Barer[t])
}
type Barer[t any] interface {
	bar(Bazer[t])
}
type Bazer[t any] interface {
	Fooer[t]
	baz(t)
}

type Int int

func (n Int) baz(int) {}
func (n Int) foo(b Barer[int]) { b.bar(n) }

type F[t any] interface { f(G[t]) }

func (x myint) foo() int {return int(x)}

type myfloat float64
func (x myfloat) foo() float64 {return float64(x) }

func f[T any](i interface{}) {
	switch x := i.(type) {
	case interface { foo() T }:
		println("fooer", x.foo())
	default:
		println("other")
	}
}
func main() {
	f[int](myint(6))
	f[int](myfloat(7))
	f[float64](myint(8))
	f[float64](myfloat(9))

			cronJob: &batchv1.CronJob{ObjectMeta: metav1.ObjectMeta{Namespace: "foo-ns", Name: "fooer"}},
			jobs: []runtime.Object{
				&batchv1.Job{ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "foo-ns"}},
				&batchv1.Job{ObjectMeta: metav1.ObjectMeta{Name: "foo1", Namespace: "foo-ns",
					OwnerReferences: []metav1.OwnerReference{{Name: "fooer", Controller: &trueRef}}}},