func _[T [10]byte]() { f := func() (x *T) { return }; f /* ERROR "cannot index" */ ()[0] = 0 }
func _[T [10]byte]() { f := func() (x *T) { return }; (*f())[0] = 0 }
func _[T *[10]byte]() { f := func() (x T) { return }; f()[0] = 0 }

// slicing

func _[T interface{ ~[10]E }, E any] (x T, i, j, k int) { var _ []E = x[i:j] }
func _[T interface{ ~[10]E }, E any] (x T, i, j, k int) { var _ []E = x[i:j:k] }

// CHECK: func{{.*}}dialect = "x"
// CHECK-NEXT: x.b
// CHECK: func{{.*}}dialect = "y"
// CHECK-NEXT: y.b
// CHECK: func{{.*}}dialect = "z"
// CHECK-NEXT: z.b
// CHECK: func{{.*}}dialect = "x"
// CHECK-NEXT: x.c
// CHECK: func{{.*}}dialect = "y"
// CHECK-NEXT: y.c
// CHECK: func{{.*}}dialect = "z"
// CHECK-NEXT: z.c

// -----

func.func @statements(%arg0: f32, %arg1: f32) -> (f32, f32) {

func (c *sigctxt) r6() uint64  { return c.regs().regs[6] }
func (c *sigctxt) r7() uint64  { return c.regs().regs[7] }
func (c *sigctxt) r8() uint64  { return c.regs().regs[8] }
func (c *sigctxt) r9() uint64  { return c.regs().regs[9] }
func (c *sigctxt) r10() uint64 { return c.regs().regs[10] }
func (c *sigctxt) r11() uint64 { return c.regs().regs[11] }
func (c *sigctxt) r12() uint64 { return c.regs().regs[12] }

func.func @foo(%arg0: tensor<1x4xf32>, %arg1: tensor<1x4xf32>) -> tensor<1x4xf32> {
  func.return %arg0 : tensor<1x4xf32>
}

func.func @bar(%arg0: tensor<2x4xf32>, %arg1: tensor<2x4xf32>) -> tensor<2x4xf32> {
  func.return %arg0 : tensor<2x4xf32>
}

func.func @foobar(%arg0: tensor<1x4xf32>, %arg1: tensor<1x4xf32>) -> tensor<1x4xf32> {
  func.return %arg0 : tensor<1x4xf32>
}

func (Type1) Func1_foo() {}
func (Type1) func2() {}

func (type2) Func1() {}

type (
	Conflict          int
	Conflict_Conflict int
	Conflict_conflict int
)

func (Conflict) Conflict() {}

func GFunc[T any]() {}

type GType[T any] int

func (GType[T]) M() {}
`
	const test = `
package p_test

func ExampleConst1() {} // invalid - no support for consts and vars

type foo8 string
type foo9 string

func (f foo1) F() { return }
func (f foo2) F() { return }
func (f foo3) F() { return }
func (f foo4) F() { return }
func (f foo5) F() { return }
func (f foo6) F() { return }
func (f foo7) F() { return }
func (f foo8) F() { return }
func (f foo9) F() { return }

func Test1(s string) I  { return foo1(s) }
func Test2(s string) I  { return foo2(s) }
func Test3(s string) I  { return foo3(s) }

}

// 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 { // ERROR "can inline n"

func (c *sigctxt) r5() uint64  { return (uint64)(c.regs().sc_x[5]) }
func (c *sigctxt) r6() uint64  { return (uint64)(c.regs().sc_x[6]) }
func (c *sigctxt) r7() uint64  { return (uint64)(c.regs().sc_x[7]) }
func (c *sigctxt) r8() uint64  { return (uint64)(c.regs().sc_x[8]) }
func (c *sigctxt) r9() uint64  { return (uint64)(c.regs().sc_x[9]) }
func (c *sigctxt) r10() uint64 { return (uint64)(c.regs().sc_x[10]) }

func (t *testInitData) KubeConfigDir() string                                { return "" }
func (t *testInitData) KubeConfigPath() string                               { return "" }
func (t *testInitData) ManifestDir() string                                  { return "" }
func (t *testInitData) KubeletDir() string                                   { return "" }
func (t *testInitData) ExternalCA() bool                                     { return false }

  func.return
}

// CHECK-LABEL: func @no_embedding_ops
func.func @no_embedding_ops(%arg0: tensor<2x2xf32>) -> (tensor<2x2xf32>) {
  // CHECK: tf.Add
  %0 = "tf.Add"(%arg0, %arg0) : (tensor<2x2xf32>, tensor<2x2xf32>) -> tensor<2x2xf32>
  func.return %0 : tensor<2x2xf32>
}

// CHECK-LABEL: func @nested_embedding_op