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(

// We have a special case for constants since they have a higher minimum value.
StatusOr<QuantizedType> GetQuantizedType(const TensorT& tensor, Builder builder,
                                         bool is_constant,
                                         mlir::Type storage_type) {
  tflite::QuantizationParametersT& quant_params = *tensor.quantization;
  if (quant_params.details.AsCustomQuantization()) {

      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\"");

    %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>)

                                         /*is_constant=*/true));
  auto shaped_type = type.dyn_cast<mlir::RankedTensorType>();
  if (!shaped_type) {
    return errors::Internal("Constant doesn't have a shape");
  }

  TF_ASSIGN_OR_RETURN(type, tfl::GetTensorType(tensor, builder,
                                               /*is_constant=*/true,

    This is defined in Tensorflow as:

    REGISTER_OP("Enter")
       .Input("data: T")
       .Output("output: T")
       .Attr("T: type")
       .Attr("frame_name: string")
       .Attr("is_constant: bool = false")
       .Attr("parallel_iterations: int = 10")

    For example:
       %res:2 = tf_executor.Enter %arg0 frame "some/frame" parallel_iterations 42 constant : tensor<*xf32>

Status SetOutputForConstant(
    OpKernelContext* ctx, bool requires_copy_to_device,
    const XlaCompiler::CompilationResult* compilation_result, int output_num) {
  CHECK(compilation_result->outputs[output_num].is_constant);
  const Tensor& const_tensor =
      compilation_result->outputs[output_num].constant_value;
  Tensor* output_tensor;
  if (requires_copy_to_device && const_tensor.TotalBytes() > 0) {

                              result.attributes))
      return failure();
  }
  bool has_constant = succeeded(parser.parseOptionalKeyword("constant"));
  result.addAttribute("is_constant", BoolAttr::get(context, has_constant));

  SmallVector<Type, 1> types;
  if (parser.parseColonTypeList(types)) return failure();
  if (types.size() != 1)

           << ')';
    if (xla_output_description.input_index >= 0)
      output << " input_index=" << xla_output_description.input_index;
    if (xla_output_description.is_constant) output << " constant";
    if (xla_output_description.is_tensor_list) output << " tensor_list";
    output << '\n';
  }

  for (const auto& resource_update : compilation_result.resource_updates) {