}
};

}  // namespace

MlrtDialect::MlrtDialect(mlir::MLIRContext *context)
    : mlir::Dialect(/*name=*/"mlrt", context,
                    mlir::TypeID::get<MlrtDialect>()) {
  addTypes<FutureType>();
  addTypes<PromiseType>();
  addTypes<AsyncHandleType>();
  addInterfaces<MlrtInlinerInterface>();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/mlrt/mlrt_ops.cpp.inc"
      >();
}

		return nil, err
	}
	d.unit = u
	return d, nil
}

// AddTypes will add one .debug_types section to the DWARF data. A
// typical object with DWARF version 4 debug info will have multiple
// .debug_types sections. The name is used for error reporting only,
// and serves to distinguish one .debug_types section from another.
func (d *Data) AddTypes(name string, types []byte) error {
	return d.parseTypes(name, types)
}

namespace tfrt {
namespace fallback {

FallbackDialect::FallbackDialect(MLIRContext *context)
    : Dialect(/*name=*/"tfrt_fallback", context,
              TypeID::get<FallbackDialect>()) {
  addTypes<TFTensorType, TFAllocatorType>();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback.cpp.inc"
      >();
}

/// Parse a type registered to this dialect.

      .def(py::init([](mlir::Location loc, std::string name) {
        return mlir::OperationState(loc, llvm::StringRef(name));
      }))
      .def("addTypes",
           [](mlir::OperationState& state, std::vector<mlir::Type> tys) {
             state.addTypes(mlir::ArrayRef<mlir::Type>(tys));
           })
      .def("addOperands",
           [](mlir::OperationState& os, std::vector<mlir::Value> ops) {

};

}  // namespace

TensorflowMlrtDialect::TensorflowMlrtDialect(mlir::MLIRContext *context)
    : mlir::Dialect(/*name=*/"tf_mlrt", context,
                    mlir::TypeID::get<TensorflowMlrtDialect>()) {
  addTypes<TFTensorType, TFDeviceType>();
  addInterfaces<TensorflowMlrtInlinerInterface>();

  addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/tfrt/ir/mlrt/tf_mlrt_ops.cpp.inc"
      >();

                         _FusedBatchNormExOp::getOperationName());
    state.addOperands(batch_norm.getOperands());
    if (side_input) state.operands.push_back(side_input);
    state.addTypes(batch_norm.getResultTypes());
    state.addAttributes(batch_norm->getAttrs());
    Operation *op = rewriter.create(state);
    rewriter.replaceOp(batch_norm, op->getResults());

class OperationState:
    def __init__(self, arg0: Location, arg1: str) -> None: ...
    def addOperands(self, arg0: list[Value]) -> None: ...
    def addRegion(self) -> Region: ...
    def addTypes(self, arg0: list[Type]) -> None: ...

class RankedTensorType(Type):
    def __init__(self, *args, **kwargs) -> None: ...
    def get(self, arg0: Type) -> RankedTensorType: ...

class Region:

  // Create the TF op
  const std::string tf_op_full_name = absl::StrCat("tf.", node_def.op());
  mlir::OperationState op_state(loc, tf_op_full_name);
  op_state.addOperands(func.getArguments());
  op_state.addTypes(output_tys);
  op_state.addAttributes(attrs);
  mlir::Operation* tf_op = op_builder.create(op_state);
  op_builder.create<mlir::func::ReturnOp>(loc, tf_op->getResults());

  // Run the decompose passes on the module

			addType(T.Elem())
		case *types.Slice:
			addType(T.Elem())
		case *types.Array:
			addType(T.Elem())
		case *types.Chan:
			addType(T.Elem())
		case *types.Map:
			addType(T.Key())
			addType(T.Elem())
		case *types.Signature:
			addType(T.Params())
			addType(T.Results())
			if tparams := T.TypeParams(); tparams != nil {
				for i := 0; i < tparams.Len(); i++ {
					addType(tparams.At(i))
				}
			}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"fmt"
)

type AddType interface {
	int | int64 | string
}

// Add can add numbers or strings
func Add[T AddType](a, b T) T {
	return a + b
}

func main() {
	if got, want := Add(5, 3), 8; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}