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 = {});

// Imports float tensor with calibration value into calibrated quantized type.
absl::StatusOr<mlir::quant::QuantizedType> GetCalibratedQuantizedType(

      ops::Placeholder(root.WithOpName("data"), DT_FLOAT), "frame_name",
      ops::internal::Enter::Attrs{}.IsConstant(true));
  EXPECT_THAT(enter.node(), NodeWith(Attr("is_constant", true)));
  EXPECT_EQ(Explain(enter.node(), NodeWith(Attr("is_constant", false))),
            "attribute named is_constant does not match value; expected: "
            "\"false\", found: \"true\"");

  input: "Const"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "frame_name"
    value {
      s: "while_context"
    }
  }
  attr {
    key: "is_constant"
    value {
      b: false
    }
  }
  attr {
    key: "parallel_iterations"
    value {
      i: 10
    }
  }
}
node {
  name: "Merge"
  op: "Merge"
  input: "Enter"

    %Const, %ctl = Const name("Const") {dtype = i32, value = dense<0> : tensor<i32>} : () -> (tensor<i32>)
    %Enter, %ctl_0 = Enter(%Const) name("while/Enter") {T = i32, frame_name = "while/while_context", is_constant = false, parallel_iterations = 10 : i64} : (tensor<i32>) -> (tensor<*xi32>)
    %NextIteration, %ctl_1 = NextIteration(%Add) name("while/NextIteration") {T = i32} : (tensor<*xi32>) -> (tensor<*xi32>)

    %Const, %ctl = Const [%arg.ctl] name("test") {dtype = i32, value = dense<0> : tensor<i32>} : () -> (tensor<i32>)
    %Enter, %ctl_0 = Enter(%Const) [%arg.ctl] name("while/Enter") {T = i32, frame_name = "while/while_context", is_constant = false, parallel_iterations = 10 : i64} : (tensor<i32>) -> (tensor<*xi32>)
    %NextIteration, %ctl_1 = NextIteration(%Const) [%arg.ctl] name("while/NextIteration") {T = i32} : (tensor<i32>) -> (tensor<*xi32>)

  input: "Const"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "frame_name"
    value {
      s: "while/while_context"
    }
  }
  attr {
    key: "is_constant"
    value {
      b: false
    }
  }
  attr {
    key: "parallel_iterations"
    value {
      i: 10
    }
  }
}
node {
  name: "while/Merge"
  op: "Merge"
  input: "while/Enter"

    DenseFPElementsAttr float_attr;
    if (matchPattern(value, m_Constant(&float_attr)) && float_attr.isSplat() &&
        float_attr.getSplatValue<APFloat>().isExactlyValue(raw_value))
      return true;
  } else if (mlir::isa<IntegerType>(element_type)) {
    DenseIntElementsAttr int_attr;
    if (matchPattern(value, m_Constant(&int_attr)) && int_attr.isSplat() &&
        int_attr.getSplatValue<APInt>() == raw_value)

namespace tensorflow {

namespace {

template <typename T>
void ExpectNodeEqual(const Node* n, gtl::ArraySlice<T> values,
                     TensorShape shape) {
  EXPECT_TRUE(n->IsConstant());
  Tensor tensor;
  TF_EXPECT_OK(GetNodeAttr(n->attrs(), "value", &tensor));
  DataType dtype;
  TF_EXPECT_OK(GetNodeAttr(n->attrs(), "dtype", &dtype));
  EXPECT_EQ(tensor.dtype(), dtype);

  LogicalResult matchAndRewrite(TFL::BatchMatMulOp bmm_op,
                                PatternRewriter& rewriter) const override {
    DenseElementsAttr constant;
    if (auto rhs = bmm_op.getY(); !matchPattern(rhs, m_Constant(&constant))) {
      // The constant may be preceded by QDQs in models with QDQ format, so we
      // should set it to the real constant.
      auto dq = dyn_cast_or_null<DequantizeOp>(rhs.getDefiningOp());

      id2.replaceAllUsesWith(id2.getInput());
      max = tf_op.getMax();
      rewriter.eraseOp(id2);
    }
    if (!matchPattern(min, m_Constant(&min_value))) return failure();
    if (!matchPattern(max, m_Constant(&max_value))) return failure();

    int quant_dim = -1;
    if (PerAxis) {
      // This is a special case that the quant_dim is the last dimensions