//
// Conditions for `tfl.fully_connected` conversion:
//   * Input tensors are per-tensor uniform quantized (i8->f32)
//     tensors.
//   * The filter tensor is constant a per-tensor uniform quantized (i8->f32)
//     tensor. The quantization dimension should be 1 (the non-contracting
//     dimension).
//   * Output tensors are per-tensor uniform quantized (i8->f32) or
//     per-channel uniform quantized (i32->f32) tensors.

  Status ToTensor(tensorflow::Tensor* dst) const;
  Status BitcastFrom(const TensorInterface& from, DataType type,
                     const int64_t* new_dims, int num_new_dims);
  Status FromProto(const tensorflow::TensorProto& from);

  tensorflow::Tensor& Tensor() { return tensor_; }

 private:
  tensorflow::Tensor tensor_;
};

inline Tensor& TensorFromInterface(AbstractTensorInterface* tensor) {

  let summary = "Loads a restored variable tensor as a tensor future";

  let description = [{
    This op loads a restored variable tensor as a tensor future. It is a
    replacement of `tf.ReadVariableOp`.

    This op returns a scalar string tensor containing the restored variable name, which 
    is composed from `container_name` and `shared_name` from a `var_handle` and can be

def FuseTransposeFCLhsToBatchMatmul : Pat<
  (TFL_BatchMatMulOp
    (TFL_FullyConnectedOp:$fc_output
      (TFL_TransposeOp TensorOf<[F32]>:$fc_lhs,
                       (Arith_ConstantOp:$perm_value $p0)),
      TensorOf<[F32]>:$fc_rhs,
      $bias, $TFL_AF_None, $TFL_FCWO_Default,
      $keep_num_dims, $asymmetric_quantize_inputs_fc
    ),
    $bmm_rhs, ConstBoolAttrTrue, $transpose_rhs,

  (TF_CastOp
    (TF_AddV2Op
      (CreateTFCastOpI32 $lhs, /*truncate=*/ConstBoolAttrFalse),
      (CreateTFCastOpI32 $rhs, /*truncate=*/ConstBoolAttrFalse)),
     /*truncate=*/ConstBoolAttrFalse),
  [(TensorOf<[TF_Uint32]> $lhs), (TensorOf<[TF_Uint32]> $rhs)]>;

//===----------------------------------------------------------------------===//
// Fill op patterns.
//===----------------------------------------------------------------------===//

    The `value` attribute contains the tensor's value (or initial value, in the
    case it is mutable).

    The `type` attribute contains the tensor's type, which for the case of
    mutable tensors might be more general than just the fixed static shape of
    the `value` attribute. For example, a global tensor might be unranked such
    as `tensor<*xf32>`, or a more complex shape such as `tensor<4x?x27xf32>`.

#include "tensorflow/compiler/mlir/lite/schema/schema_generated.h"
#include "tensorflow/core/framework/tensor.pb.h"
#include "tensorflow/core/framework/tensor_shape.pb.h"

namespace mlir {
namespace TFL {

bool IsQuantized(const tflite::TensorT& tensor);

absl::StatusOr<mlir::quant::QuantizedType> GetQuantizedType(
    const tflite::TensorT& tensor, mlir::Builder builder,
    bool is_constant = false, mlir::Type storage_type = {});

namespace tensorflow {
namespace ops {

// Return a tensor with the same shape and contents as the input tensor or
// value.
Status Identity(AbstractContext* ctx, AbstractTensorHandle* const input,
                AbstractTensorHandle** output, const char* name = nullptr,
                const char* raw_device_name = nullptr);

// Returns a list of tensors with the same shapes and contents as the input

// as tensor names may have changed via MLIR constant folding process.
bool ExpectEqualTensor(const Tensor* tensor, const Tensor* expected_tensor) {
  return (tensor->is_variable() == expected_tensor->is_variable()) &&
         (GetAsVector(tensor->shape()) ==
          GetAsVector(expected_tensor->shape()));
}

// Finds the match of the quantized tensor from the possible tensors. Each

def PromiseOp: TensorflowMlrt_Op<"promise", []> {
  let summary = "Set a tensor in a promise";

  let description = [{
    Set a tensor in a promise.

    $promise: A value of type !mlrt.promise. The underlying value must be a tensorflow tensor.
    $tensor: A tensorflow tensor.
  }];

  let arguments = (ins
    MlrtPromiseType:$promise,
    TFTensorType:$tensor
  );

  let assemblyFormat = "operands attr-dict";
}