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

}

// Test that a defer after a successful recovery looks like it is called directly
// from the function with the defers.
func TestCallersAfterRecovery(t *testing.T) {
	want := []string{"runtime.Callers", "runtime_test.TestCallersAfterRecovery.func1", "runtime_test.TestCallersAfterRecovery"}

	defer func() {
		pcs := make([]uintptr, 20)
		pcs = pcs[:runtime.Callers(0, pcs)]
		testCallersEqual(t, pcs, want)
	}()
	defer func() {

  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

        return LogicalResult::failure();
      }
      if (!llvm::isa<func::FuncOp>(symbol)) {
        func.emitError() << "Invalid callee: " << caller.getF();
        return LogicalResult::failure();
      }
      auto callee =
          llvm::dyn_cast<func::FuncOp>(symbol_table.lookup(caller.getF()));
      auto& src_region = callee.getRegion();