file("src/main/headers/funcs.h") << """
            int func1();
            int func2();
"""
        file("src/main/cpp/main.cpp") << """
            #include <iostream>
            #include "funcs.h"
            int main () {
                std::cout << func1() << func2() << std::endl;
                return 0;
            }
"""
        file("src/main/cpp/func1.cpp") << """
            #include "lib.h"

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread

int Func1() {
	return 0;
}

void Func2(int x) {
	(void)x;
}
*/
import "C"

func main() {
	const N = 10000
	done := make(chan bool, N)
	for i := 0; i < N; i++ {
		go func() {
			C.Func1()
			done <- true
		}()
		go func() {
			C.Func2(0)
			done <- true
		}()
	}
	for i := 0; i < 2*N; i++ {
		<-done
	}

func (r Option[T]) OrElse(t T) T {
	if r.IsDefined() {
		return *r.v
	}
	return t
}

func (r Option[T]) Recover(f func() T) Option[T] {
	if r.IsDefined() {
		return r
	}
	t := f()
	return Option[T]{&t}
}

type Func1[A1, R any] func(a1 A1) R

type Func2[A1, A2, R any] func(a1 A1, a2 A2) R

func (r Func2[A1, A2, R]) Curried() Func1[A1, Func1[A2, R]] {
	return func(a1 A1) Func1[A2, R] {

}

func TestClassifyExamples(t *testing.T) {
	const src = `
package p

const Const1 = 0
var   Var1   = 0

type (
	Type1     int
	Type1_Foo int
	Type1_foo int
	type2     int

	Embed struct { Type1 }
	Uembed struct { type2 }
)

func Func1()     {}
func Func1_Foo() {}
func Func1_foo() {}
func func2()     {}

func (Type1) Func1() {}
func (Type1) Func1_Foo() {}

        %1 = "tf.opB"() : () -> tensor<f32>
        tf_executor.yield %1 : tensor<f32>
      }
      tf_executor.fetch %outputs_0 : tensor<f32>
    }
    func.return %0 : tensor<f32>
  }
// CHECK-LABEL: func @func2
  func.func @func2(%arg0: tensor<i1>) -> tensor<i1> {
    %0 = tf_executor.graph {
      %outputs, %control = tf_executor.island {
        %1 = "tf.opB"() : () -> tensor<f32>

// `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() }