// `funcB` for `funcB_renamed` after the module is lowered to TFRT. Note that,
// `funcB_renamed` are called twice, so `CreateGuaranteeAllFuncsOneUsePass` will
// make a replicaion of `funcB_renamed` with a different name.

module attributes {tf.versions = {bad_consumers = [], min_consumer = 0 : i32, producer = 567 : i32}} {
  // CHECK-LABEL: @funcA

  %3 = func.call @arg_reuse_test_2(%arg0, %0, %1) {tac.interface_name = "func2"} : (tensor<4x384x32xf32>, tensor<3xi32>, tensor<3xi32>) -> tensor<1x384x32xf32>
  func.return %2, %3 : tensor<1x384x32xf32>, tensor<1x384x32xf32>
}

// PARTIAL-LABEL: @arg_reuse_test_1
func.func @arg_reuse_test_1(%arg0: tensor<4x384x32xf32>, %arg1: tensor<3xi32>, %arg2: tensor<3xi32>) -> tensor<1x384x32xf32> attributes {tac.interface_name = "func1"} {

	f = func() { // ERROR "func literal escapes to heap" "can inline f1.func2"
		p = alloc(3) // ERROR "inlining call to alloc" "moved to heap: x"
	}
	f()
}

func f2() {} // ERROR "can inline f2"

// No inline for recover; panic now allowed to inline.
func f3() { panic(1) } // ERROR "can inline f3" "1 escapes to heap"
func f4() { recover() }

func f5() *byte { // ERROR "can inline f5"

        given:
        sourceFile << """
            #define FUNC1(X) X
            #define FUNC2(X) (X)
            #define ARGS ("hello.h")

            #define HEADER_(X) X
            #define HEADER(X) HEADER_(FUNC1 FUNC2 X)

            #include HEADER(ARGS) // replaced by FUNC1 FUNC2 ("hello.h") then FUNC1 ("hello.h")
        """

        expect:
        resolve() == [header]
    }

func (n *Func) editChildren(edit func(Node) Node)           { editNodes(n.Body, edit) }
func (n *Func) editChildrenWithHidden(edit func(Node) Node) { editNodes(n.Body, edit) }

func (f *Func) Type() *types.Type                { return f.Nname.Type() }
func (f *Func) Sym() *types.Sym                  { return f.Nname.Sym() }
func (f *Func) Linksym() *obj.LSym               { return f.Nname.Linksym() }

// Test evaluation order.

package main

var calledf int

func f() int {
	calledf++
	return 0
}

func g() int {
	return calledf
}

var xy string

//go:noinline
func x() bool {
	xy += "x"
	return false
}

//go:noinline
func y() string {
	xy += "y"
	return "abc"
}

func main() {
	if f() == g() {
		panic("wrong f,g order")
	}

      /*saver_def=*/std::nullopt,
      /*function_aliases=*/{{"func1", "alias1"}, {"func2", "alias2"}},
      /*asset_file_defs=*/{});
  ASSERT_THAT(exported_model.function_aliases(), SizeIs(2));
  EXPECT_TRUE(exported_model.function_aliases().contains("func1"));
  EXPECT_THAT(exported_model.function_aliases().at("func1"), StrEq("alias1"));
  EXPECT_TRUE(exported_model.function_aliases().contains("func2"));

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

// Test that result parameters are in the same scope as regular parameters.
// Does not compile.

package main

func f1(a int) (int, float32) {
	return 7, 7.0
}


func f2(a int) (a int, b float32) { // ERROR "duplicate argument a|definition|redeclared"
	return 8, 8.0

func add(x, y int) int {
	return x + y
}

func fn() func(int, int) int {
	return f
}

var fc func(int, int, chan int)

func addc(x, y int, c chan int) {
	c <- x+y
}

func fnc() func(int, int, chan int) {
	return fc
}

func three(x int) {
	if x != 3 {
		println("wrong val", x)
		panic("fail")
	}
}

var notmain func()

func emptyresults() {}
func noresults()    {}

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

// Test closures in if conditions.

package main

func main() {
	if func() bool { return true }() {}  // gc used to say this was a syntax error
	if (func() bool { return true })() {}
	if (func() bool { return true }()) {}