type _ struct { m int }
type _ struct { m int }

func (_ /* ERROR "cannot use _" */) m() {}
func m(_ /* ERROR "cannot use _" */) {}

// Methods with receiver base type declared in another file.
func (T3) m1() {}
func (*T3) m2() {}
func (x T3) m3() {}
func (x *T3) f /* ERROR "field and method" */ () {}

// Methods of non-struct type.
type T4 func()

func (self T4) m() func() { return self }

// CHECK: func @callee4()
func.func @callee4() {
  // CHECK:      [[CALLEE4_INIT_TOKEN:%.*]] = mhlo.create_token

  // CHECK:      [[CALL_5:%.*]] = call @callee5([[CALLEE4_INIT_TOKEN]])
  func.call @callee5() : () -> ()

  // CHECK:      return
  func.return
}

// CHECK: func private @callee5([[CALLEE5_ARG0:%.*]]: !mhlo.token) -> !mhlo.token
func.func private @callee5() {
  // CHECK-NOT:  mhlo.create_token

}

type podSecurityContextWrapper struct {
	podSC *api.PodSecurityContext
}

func (w *podSecurityContextWrapper) PodSecurityContext() *api.PodSecurityContext {
	return w.podSC
}

func (w *podSecurityContextWrapper) ensurePodSC() {
	if w.podSC == nil {
		w.podSC = &api.PodSecurityContext{}
	}
}

func (w *podSecurityContextWrapper) HostNetwork() bool {
	if w.podSC == nil {
		return false
	}

func.func private @f(%arg0: tensor<f32>, %arg1: tensor<f32>) {
  return
}

// CHECK-LABEL: removes_all_args
func.func @removes_all_args(%arg0: tensor<f32>, %arg1: tensor<f32>) {
  // CHECK: call{{.*}}() :
  func.call @f(%arg0, %arg1) : (tensor<f32>, tensor<f32>) -> ()
  return
}

// -----

// CHECK-LABEL: handles_mlprogram
// CHECK-SAME: () {

func DoublePanic() {
	defer func() {
		panic(P("YYY"))
	}()
	panic(P("XXX"))
}

// Test that panic while panicking discards error message
// See issue 52257
type exampleError struct{}

func (e exampleError) Error() string {
	panic("important multi-line\nerror message")
}

func ErrorPanic() {
	panic(exampleError{})
}

type examplePanicError struct{}

func (e examplePanicError) Error() string {

  func.func @convert(%arg0: tensor<2xi32>) -> tensor<2xf32> {
    // CHECK: mhlo.convert %arg0 : (tensor<2xi32>) -> tensor<2xf32>
    %0 = "tf.Cast"(%arg0) {Truncate = false} : (tensor<2xi32>) -> tensor<2xf32>
    func.return %0 : tensor<2xf32>
  }

  // CHECK-LABEL: func @constant
  func.func @constant(%arg0: tensor<f32>) -> tensor<f32> {
    // CHECK: %[[ONE:.*]] = mhlo.constant dense<1.000000e+00> : tensor<f32>

type MyString string
type MyFunc1 func(func(int) bool)
type MyFunc2 func(int) bool
type MyFunc3 func(MyFunc2)

type T struct{}

func (*T) PM() {}
func (T) M()   {}

func f1()                             {}
func f2(func())                       {}
func f4(func(int) bool)               {}
func f5(func(int, string) bool)       {}
func f7(func(int) MyBool)             {}
func f8(func(MyInt, MyString) MyBool) {}

	}{
		{
			func() { klog.Error("foo") },
			"error\tklog\tfoo$",
		},
		{
			func() { klog.Error("foo") },
			"foo$",
		},
		{
			func() { klog.Errorf("fmt %v", "item") },
			"fmt item$",
		},
		{
			func() { klog.Errorf("fmt %v", "item") },
			"fmt item$",
		},
		{
			func() { klog.ErrorS(errors.New("my error"), "info") },
			"error\tklog\tmy error: info",
		},
		{
			func() { klog.Info("a", "b") },

// any re-assignment prevents closure inlining
func m() int {
	foo := func() int { return 1 } // ERROR "can inline m.func1" "func literal does not escape"
	x := foo()
	foo = func() int { return 2 } // ERROR "can inline m.func2" "func literal does not escape"
	return x + foo()
}

// address taking prevents closure inlining
func n() int {
	foo := func() int { return 1 } // ERROR "can inline n.func1" "func literal does not escape"
	bar := &foo

// TODO: Make this a compiler intrinsic
func getfp() uintptr { return 0 }

func setProcessCPUProfiler(hz int32) {}
func setThreadCPUProfiler(hz int32)  {}
func sigdisable(uint32)              {}
func sigenable(uint32)               {}
func sigignore(uint32)               {}

// Stubs so tests can link correctly. These should never be called.