fooer 6
other
other

// is called without a receiver.

package main

type Fooer interface {
	Foo(i, j int)
}

func f(x int) {
}

type I interface {
	M(int)
}
type T struct{}

func (t T) M(x int) {
}

func g() func(int)

func main() {
	Fooer.Foo(5, 6) // ERROR "not enough arguments in call to method expression Fooer.Foo|incompatible type|not enough arguments"

	var i I
	var t *T

// 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 ssa

type T struct{}

func (T) foo() {}

type fooer interface {
	foo()
}

func Works(v interface{}) {
	switch v.(type) {
	case interface{}:
		v.(fooer).foo()
	}
}

func Panics(v interface{}) {
	switch v.(type) {
	case interface{}:
		v.(fooer).foo()
		v.(interface{ foo() }).foo()
	}

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

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

package ssa

type T struct{}

func (T) foo() {}

type fooer interface {
	foo()
}

func Unused(v interface{}) {
	v.(fooer).foo()
	v.(interface{ foo() }).foo()

	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: