#define TENSORFLOW_COMPILER_MLIR_QUANTIZATION_COMMON_FUNC_H_

#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project

namespace mlir::quant {

// Returns a public `func::FuncOp` in `module_op` whose name matches either
// `main` or `serving_default`. If `func::FuncOps` with both names exist, the
// function with name "main" takes precedence. Returns null if no such a

// CHECK-LABEL: func @func_attr
// CHECK-SAME: tf._implements = #tf_type.func<@symbol_a, {attr0 = 1 : i32, attr1 = "random"}>
func.func @func_attr() attributes {tf._implements = #tf_type.func<@symbol_a, {attr0 = 1 : i32, attr1 = "random"}>} {
  func.return
}

// CHECK-LABEL: func @nested_func_attr

func.func @main() attributes {tf._implements = #tf_type.func<@symbol>} {
  func.return
}

// -----

// expected-error@+1 {{expected symbol while parsing tf.func attribute}}
func.func @main() attributes {tf._implements = #tf_type.func<{}>} {
  func.return
}

// -----

// expected-error@+1 {{expected empty string or symbol while parsing tf.func attribute}}

package main

func run() { // ERROR "cannot inline run: recursive"
	f := func() { // ERROR "can inline run.func1 with cost .* as:.*" "func literal does not escape"
		g() // ERROR "inlining call to g"
	}
	f() // ERROR "inlining call to run.func1" "inlining call to g"
	run()
}

func g() { // ERROR "can inline g with cost .* as:.*"
}

func main() { // ERROR "can inline main with cost .* as:.*"

  input: "input"
  input: "input"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }
}
node {
  name: "func0"
  op: "func_name"
  input: "Switch0:1"
}
node {
  name: "Merge"
  op: "Merge"
  input: "Switch0:1"
  input: "Switch0"
  input: "^func0"
  attr {
    key: "N"
    value {
      i: 2
    }
  }
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }

package main

type hello struct{}

func main() {
	_ = Some(hello{})
	res := Applicative2(func(a int, b int) int {
		return 0
	})
	_ = res
}

type NoneType[T any] struct{}

func (r NoneType[T]) Recover() any {
	return nil
}

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

func Some[T any](v T) any {
	_ = Some2[T](v)
	return NoneType[T]{}.Recover()
}

	sehf1pc := abi.FuncPCABIInternal(sehf1)
	var fnwithframe func()
	fnwithframe = func() {
		fnwithframe()
	}
	fnwithoutframe := func() {}
	tests := []struct {
		name     string
		pc       uintptr
		hasframe bool
	}{
		{"no frame func", abi.FuncPCABIInternal(sehf2), false},
		{"no func", sehf1pc - 1, false},
		{"func at entry", sehf1pc, true},
		{"func in prologue", sehf1pc + 1, true},

# CHECK-LABEL:       func @main() {

# Verify that the NameAttrList is properly turned into reference to functions on import
# CHECK:    tf.Case
# CHECK-SAME: branches = [@[[FOO:[a-z0-9]+]], @[[BAR:[a-z0-9]+]]]
# CHECK-DAG:  func private @[[FOO]]()
# CHECK-DAG:  func private @[[BAR]]()

node {
  name: "predicate"
  op: "Const"
  attr {
    key: "dtype"

// due to propagation of addrtaken to outer variables for
// closure variables.

package p

type T struct {
	s [2]string
}

func f(a T) { // ERROR "live at entry to f: a$"
	var e interface{} // ERROR "stack object e interface \{\}$"
	func() {          // ERROR "live at entry to f.func1: &e a$"
		e = a.s // ERROR "live at call to convT: &e$" "stack object a T$"
	}()
	// Before the fix, both a and e were live at the previous line.

# CHECK-DAG: func private @custom_embedding_matmul{{[0-9]*}}(){{.+}}tf._implements = #tf_type.func<@tensorflow.embedding_matmul, {key1 = 2 : i64, key2 = false}>, tf._original_func_name = "custom_embedding_matmul"}...