// Converts tf.Const to arith.constant for statically shaped, non-opaque constants.
// Needed for QuantizationDriver to recognize constants.
def ConvertTfConstToArithConst : Pat<
  (TF_ConstOp:$res DenseElementsAttr:$value),
  (Arith_ConstantOp $value),

// Converts reamaining arith.constant ops from quantization passes back to
// tf.Const ops.
def ConvertArithConstToTfConst : Pat<
  (Arith_ConstantOp:$res DenseElementsAttr:$value),
  (TF_ConstOp $value),

def : Pat<(TF_RiscAddOp $l, $r), (MHLO_AddOp $l, $r)>;

def : Pat<(TF_RiscDotOp $a, $b, $transpose_a, $transpose_b),
          (MHLO_DotOp
          (TF_TransposeOp $a, (TF_ConstOp (Get2DTransposePerm $transpose_a))),
          (TF_TransposeOp $b, (TF_ConstOp (Get2DTransposePerm $transpose_b))),
          /*precision_config=*/(NullArrayAttr))>;

//===----------------------------------------------------------------------===//

                                          reduction_indices, keep_dims)
                 .getOperation();
           });

  // mlir::TF::ConstOp
  py::class_<mlir::TF::ConstOp>(m, "Tf_ConstOp")
      .def("create",
           [](mlir::OpBuilder& opb, mlir::Location loc,
              mlir::Attribute value) -> mlir::Operation* {
             return opb.create<mlir::TF::ConstOp>(loc, value).getOperation();

class Tf_AnyOp:
    def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: Location, arg1: Value, arg2: Value, arg3: bool) -> Operation: ...

class Tf_ConstOp:
    def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: Location, arg1) -> Operation: ...

class Tf_EqualOp:
    def __init__(self, *args, **kwargs) -> None: ...

  : NativeCodeCall<"$_builder.create<ConstOp>($_loc, $0.getType(), $1)">;

def LegalizeTFConstToTFLConst: Pat<(TF_ConstOp:$res ElementsAttr:$value),
                                   (createConstOp $res, $value)>;

// Convert to std constant for statically shaped, non-opaque constants.
def ConvertTfConstToStdConst : Pat<
  (TF_ConstOp:$res DenseElementsAttr:$value),
  (Arith_ConstantOp $value),
  [(AnyStaticShapeTensor $res)], [], (addBenefit 10)>;

//                             (TF_SquaredDifferenceOp $x, $new_mean),
//                             (TF_ConstOp [0,1,2])),
//                         (TF_ConstOp $epsilon))))),
//         (TF_SubOp
//             $offset,
//             (TF_MulOp
//                 (TF_MeanOp $x, (TF_ConstOp [0,1,2])),
//                 $multiplier))),
//    // We already guaranteed that the last five results have no use so it does

   (HasOneUse $input_neg_out)]>;

// The constant folding in this pass might produce constant in the tf dialect.
// This rule is to legalize these constant to the tfl dialect.
def LegalizeConstOp : Pat<
  (TF_ConstOp ElementsAttr:$value), (TFL_ConstOp $value)>;

// Reorders adds to allow constant folding.
// Add --> Add $input, $constantA
//    \--> $constantB
// To
// Add --> $input

  let hasVerifier = 1;

  let hasCanonicalizer = 1;

}

// In MLIR, the TensorFlow tensor value is represented as an ElementsAttr, with
// its type encoding the tensor's shape and data type.
def TF_ConstOp : TF_Op<"Const", [ConstantLike, Pure,
    DeclareOpInterfaceMethods<InferTypeOpInterface>,
    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
  let summary = "Constant tensor op";