// conflict with local non-generic types and local variables.
func caller0() {
	type X[T any] struct {
		fn Fn[int]
	}

	x := X[int]{func(v int) { fmt.Println(v) }}
	x.fn(0)
}

func caller1(val int) {
	type X[T any] struct {
		fn FnErr[int]
	}

	x := X[int]{func(v int) error { fmt.Println(v); return nil }}
	x.fn(0)
}

func caller1a(val int) {
	type X struct {
		fn func(float64) error
	}

	return p
}

func caller0a() {
	i := 0
	_ = param0(&i)
}

func caller0b() {
	i := 0 // ERROR "moved to heap: i$"
	sink = param0(&i)
}

// in, in -> out, out
func param1(p1, p2 *int) (*int, *int) { // ERROR "leaking param: p1 to result ~r0" "leaking param: p2 to result ~r1"
	return p1, p2
}

func caller1() {
	i := 0 // ERROR "moved to heap: i$"
	j := 0

type CallResult struct {
	From      Caller
	Opts      CallOptions
	Responses echo.Responses
}

type Caller interface {
	// Call from this Instance to a target Instance.
	Call(options CallOptions) (CallResult, error)
	CallOrFail(t test.Failer, options CallOptions) CallResult
}

type Callers []Caller

// Instances returns an Instances if all callers are Instance, otherwise returns nil.

  // CHECK-SAME: f = @callee1
  %0 = "tf.Identity"(%arg0) : (tensor<i32>) -> tensor<i32>
  %1 = "tf.PartitionedCall"(%arg0) {config = "", config_proto = "", executor_type = "", f = @callee1} : (tensor<i32>) -> tensor<i32>
  func.return %1 : tensor<i32>
}

// CHECK-LABEL: func @callee1
// CHECK-SAME: ([[ARG0:%.*]]: tensor<i32>)
func.func @callee1(%arg0: tensor<i32>) -> tensor<i32> {

  z-index: 2;
}
/* Box highlighting via shadows to avoid size changes */
.hilite { box-shadow: 0px 0px 0px 2px #000; z-index: 1; }
.hilite2 { box-shadow: 0px 0px 0px 2px #000; z-index: 1; }
/* Gap left between callers and callees */
.separator {
  position: absolute;
  text-align: center;
  font-size: 12pt;
  font-weight: bold;
}
/* Ensure that pprof menu is above boxes */
.submenu { z-index: 3; }
/* Right-click menu */

import (
	"go/ast"
	"go/types"

	"golang.org/x/tools/go/ast/astutil"
	"golang.org/x/tools/internal/typeparams"
)

// Callee returns the named target of a function call, if any:
// a function, method, builtin, or variable.
//
// Functions and methods may potentially have type parameters.
func Callee(info *types.Info, call *ast.CallExpr) types.Object {
	fun := astutil.Unparen(call.Fun)

	// Look through type instantiation if necessary.

package main

import (
	"runtime"
)

func main() {
	println(caller().frame.Function)

	// Used to erroneously print "main.call.name" instead of
	// "main.main".
	println(caller().name())
}

func caller() call {
	var pcs [3]uintptr
	n := runtime.Callers(1, pcs[:])
	frames := runtime.CallersFrames(pcs[:n])
	frame, _ := frames.Next()
	frame, _ = frames.Next()

}

func TestAuthenticate_clientCertAuthenticator(t *testing.T) {
	callerID := "test.identity"
	ids := []util.Identity{
		{Type: util.TypeURI, Value: []byte(callerID)},
	}
	sanExt, err := util.BuildSANExtension(ids)
	if err != nil {
		t.Error(err)
	}

	testCases := map[string]struct {
		certChain          [][]*x509.Certificate
		caller             *security.Caller
		authenticateErrMsg string
		fakeAuthInfo       *mockAuthInfo

// The log record contains the source position of the caller of Infof.
func Infof(logger *slog.Logger, format string, args ...any) {
	if !logger.Enabled(context.Background(), slog.LevelInfo) {
		return
	}
	var pcs [1]uintptr
	runtime.Callers(2, pcs[:]) // skip [Callers, Infof]
	r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf(format, args...), pcs[0])

)

type Instances []Instance

func (i Instances) Callers() echo.Callers {
	var out echo.Callers
	for _, instance := range i {
		out = append(out, instance)
	}
	return out
}

// Instance represents a deployed Ingress Gateway instance.
type Instance interface {
	echo.Caller
	// HTTPAddresses returns the external HTTP (80) address of the ingress gateway ((or the NodePort address,