// RUN: flatbuffer_translate -mlir-to-tflite-flatbuffer %s -emit-custom-ops -emit-builtin-tflite-ops=false -o - | flatbuffer_to_string - | FileCheck %s

// CHECK: {
// CHECK:   version: 3,
// CHECK:   operator_codes: [ {
// CHECK:     deprecated_builtin_code: 32,
// CHECK:     custom_code: "SomeOperation",
// CHECK:     builtin_code: CUSTOM
// CHECK:   } ],
// CHECK:   subgraphs: [ {
// CHECK:     tensors: [ {
// CHECK:       shape: [  ],

// RUN: flatbuffer_translate -mlir-to-tflite-flatbuffer %s -emit-custom-ops -emit-builtin-tflite-ops=false -o - | flatbuffer_to_string - | FileCheck %s

func.func @main() -> tensor<4xi4> {
  // CHECK: {
  // CHECK:   version: 3,
  // CHECK:   operator_codes: [  ],
  // CHECK:   subgraphs: [ {
  // CHECK:     tensors: [ {
  // CHECK:       shape: [ 4 ],
  // CHECK:       type: INT4,
  // CHECK:       buffer: 1,
  // CHECK:       name: "Const",

  %0 = builtin.unrealized_conversion_cast to tensor<7xf32>
  return %0 : tensor<7xf32>
}
func.func @next(%arg0: tensor<7xf32>, %arg1: tensor<3xf32>) -> tensor<6xf32> {
  %0 = builtin.unrealized_conversion_cast to tensor<6xf32>
  return %0 : tensor<6xf32>
}
func.func @finalize(%arg0: tensor<6xf32>, %arg1: tensor<2xf32>) -> tensor<5xf32> {
  %0 = builtin.unrealized_conversion_cast to tensor<5xf32>

			typVal := info.Types[n.Fun]
			switch {
			case typVal.IsType():
				// Type conversion, which is safe.
			case typVal.IsBuiltin():
				// Builtin func, conservatively assumed to not
				// be safe for now.
				safe = false
				return false
			default:
				// A non-builtin func or method call.
				// Conservatively assume that all of them have
				// side effects for now.
				safe = false
				return false
			}

	return &Label{object{pos: pos, pkg: pkg, name: name, typ: Typ[Invalid], color_: black}, false}
}

// A Builtin represents a built-in function.
// Builtins don't have a valid type.
type Builtin struct {
	object
	id builtinId
}

func newBuiltin(id builtinId) *Builtin {
	return &Builtin{object{name: predeclaredFuncs[id].name, typ: Typ[Invalid], color_: black}, id}
}

		{TypeParam{}, 28, 48},
		{term{}, 12, 24},

		// Objects
		{PkgName{}, 64, 104},
		{Const{}, 64, 104},
		{TypeName{}, 56, 88},
		{Var{}, 64, 104},
		{Func{}, 64, 104},
		{Label{}, 60, 96},
		{Builtin{}, 60, 96},
		{Nil{}, 56, 88},

		// Misc
		{Scope{}, 60, 104},
		{Package{}, 44, 88},
		{_TypeSet{}, 28, 56},
	}

	for _, test := range tests {
		got := reflect.TypeOf(test.val).Size()

  // flexibility of supporting multiple subtypes in the future.
  variant_tensors:[VariantSubType];
}

// A list of builtin operators. Builtin operators are slightly faster than custom
// ones, but not by much. Moreover, while custom operators accept an opaque
// object containing configuration parameters, builtins have a predetermined
// set of acceptable options.
// LINT.IfChange
enum BuiltinOperator : int32 {
  ADD = 0,

		{TypeParam{}, 28, 48},
		{term{}, 12, 24},

		// Objects
		{PkgName{}, 48, 88},
		{Const{}, 48, 88},
		{TypeName{}, 40, 72},
		{Var{}, 48, 88},
		{Func{}, 48, 88},
		{Label{}, 44, 80},
		{Builtin{}, 44, 80},
		{Nil{}, 40, 72},

		// Misc
		{Scope{}, 44, 88},
		{Package{}, 44, 88},
		{_TypeSet{}, 28, 56},
	}
	for _, test := range tests {
		got := reflect.TypeOf(test.val).Size()
		want := test._32bit

  // represented with -1.
  shape_signature:[int]; // Optional.
}

// A list of builtin operators. Builtin operators are slightly faster than custom
// ones, but not by much. Moreover, while custom operators accept an opaque
// object containing configuration parameters, builtins have a predetermined
// set of acceptable options.
// LINT.IfChange
enum BuiltinOperator : int32 {
  ADD = 0,

	nodeFilter := []ast.Node{
		(*ast.CallExpr)(nil),
	}
	inspect.Preorder(nodeFilter, func(n ast.Node) {
		call := n.(*ast.CallExpr)
		b, ok := typeutil.Callee(pass.TypesInfo, call).(*types.Builtin)
		if ok && b.Name() == "append" && len(call.Args) == 1 {
			pass.ReportRangef(call, "append with no values")
		}
	})

	return nil, nil