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

  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"

                                         /*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) {