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

// 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]) }

			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}}}},

		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
		defer noop(tee(&u))
		defer noop(&v, &w)
	}
}

type Fooer interface {
	Foo()
}

type LimitedFooer struct {
	Fooer
	N int64
}

func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r$"
	return &LimitedFooer{r, n} // ERROR "&LimitedFooer{...} escapes to heap$"
}

		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
		defer noop(tee(&u))
		defer noop(&v, &w)
	}
}

type Fooer interface {
	Foo()
}

type LimitedFooer struct {
	Fooer
	N int64
}

func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r$"
	return &LimitedFooer{r, n} // ERROR "&LimitedFooer{...} escapes to heap$"
}