if f, ok := Callee(info, call).(*types.Func); ok && !interfaceMethod(f) {
		return f
	}
	return nil
}

func interfaceMethod(f *types.Func) bool {
	recv := f.Type().(*types.Signature).Recv()
	return recv != nil && types.IsInterface(recv.Type())

//	"slog.Logger.With" (instead of "(*log/slog.Logger).With")
func shortName(fn *types.Func) string {
	var r string
	if recv := fn.Type().(*types.Signature).Recv(); recv != nil {
		if _, named := typesinternal.ReceiverNamed(recv); named != nil {
			r = named.Obj().Name()
		} else {
			r = recv.Type().String() // anon struct/interface
		}
		r += "."
	}
	return fmt.Sprintf("%s.%s%s", fn.Pkg().Name(), r, fn.Name())
}

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

package main

func main() {	
	c := make(chan bool, 1);
	select {
	case _ = <-c:
		panic("BUG: recv should not");
	default:
	}
	c <- true;
	select {
	case _ = <-c:
	default:
		panic("BUG: recv should");
	}

// parameters, and results, any of which may be nil.
func NewSignature(recv *Field, params, results []*Field) *Type {
	startParams := 0
	if recv != nil {
		startParams = 1
	}
	startResults := startParams + len(params)

	allParams := make([]*Field, startResults+len(results))
	if recv != nil {
		allParams[0] = recv
	}
	copy(allParams[startParams:], params)
	copy(allParams[startResults:], results)

// token to its generated `mhlo.recv`.

// CHECK-LABEL: func @host_compute_no_operands_one_result
func.func @host_compute_no_operands_one_result() {
  // CHECK:      [[INIT_TOKEN:%.*]] = mhlo.create_token

  // CHECK-NOT:  "mhlo.send"
  // CHECK-NOT:  "mhlo.after_all"
  // CHECK:      "mhlo.recv"([[INIT_TOKEN]])

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

package main

type Chan[T any] chan Chan[T]

func (ch Chan[T]) recv() Chan[T] {
	return <-ch
}

func main() {
	ch := Chan[int](make(chan Chan[int]))
	go func() {
		ch <- make(Chan[int])
	}()
	ch.recv()

		if name == "comment" {
			return "go/doc/comment", true
		}
		return DefaultLookupPackage(name)
	}
	p.LookupSym = func(recv, name string) (ok bool) {
		if recv == "Parser" && name == "Parse" ||
			recv == "" && name == "Doc" ||
			recv == "" && name == "NoURL" {
			return true
		}
		return false
	}

	stripDollars := func(b []byte) []byte {
		// Remove trailing $ on lines.

func isTimeDotFormat(f *types.Func) bool {
	if f.Name() != "Format" || f.Pkg() == nil || f.Pkg().Path() != "time" {
		return false
	}
	// Verify that the receiver is time.Time.
	recv := f.Type().(*types.Signature).Recv()
	return recv != nil && analysisutil.IsNamedType(recv.Type(), "time", "Time")
}

func isTimeDotParse(f *types.Func) bool {
	return analysisutil.IsFunctionNamed(f, "time", "Parse")
}

		// In this case, the type of f is an interface that is itself the receiver
		// type of all of its methods. Because we have no type name to break
		// cycles, substituting in the recv results in an infinite loop of
		// recv->interface->recv->interface->...
		recv := t.recv

		params := subst.tuple(t.params)
		results := subst.tuple(t.results)
		if params != t.params || results != t.results {
			return &Signature{
				rparams: t.rparams,

		// In this case, the type of f is an interface that is itself the receiver
		// type of all of its methods. Because we have no type name to break
		// cycles, substituting in the recv results in an infinite loop of
		// recv->interface->recv->interface->...
		recv := t.recv

		params := subst.tuple(t.params)
		results := subst.tuple(t.results)
		if params != t.params || results != t.results {
			return &Signature{
				rparams: t.rparams,