// RUN: tf-opt %s -quant-import-stats --quant-test-stats='entries { name: "op" params { min_max { min: -1 max: 1 } } } entries { name: "op_0:0" params { min_max { min: -2 max: 2 } } }  entries { name_regex: "op_*" params { min_max { min: -3 max: 3 } } }' | FileCheck %s


// CHECK-LABEL: import_stats_skip
func.func @import_stats_skip(%arg0: tensor<4xf32>, %cst: tensor<i32>) -> (tensor<2xf32>,tensor<2xf32>) {

// CHECK:      %[[OP_J:[a-z0-9]*]] = "tf.opJ"
// CHECK:      %[[OP_K:[a-z0-9]*]] = "tf.opK"
// CHECK:      %[[OP_L:[a-z0-9]*]] = "tf.opL"
// CHECK:      tf_device.replicate
// CHECK-SAME: [%[[OP_A]], %[[OP_B]], %[[OP_C]]] as %{{[a-z0-9]*}}: tensor<*xi1>
// CHECK-SAME: [%[[OP_D]], %[[OP_E]], %[[OP_F]]] as %{{[a-z0-9]*}}: tensor<*xi32>
// CHECK-SAME: [%[[OP_G]], %[[OP_H]], %[[OP_I]]] as %{{[a-z0-9]*}}: tensor<*xf32>

    // CHECK: [[OP_A:%.*]] = "tf.OpA"
    %op_a = "tf.OpA"() : () -> tensor<f32>
    // CHECK: [[OP_B:%.*]] = "tf.OpB"
    %op_b = "tf.OpB"() : () -> tensor<i32>
    // CHECK-NOT: tf.AssignVariableOp
    "tf.AssignVariableOp"(%arg0, %op_a) : (!tf_res_f32, tensor<f32>) -> ()
    // CHECK: tf_device.return [[OP_B]], [[OP_A]] : tensor<i32>, tensor<f32>
    tf_device.return %op_b : tensor<i32>
  }

  Statement("AbstractOperationPtr $0(ctx->CreateOperation())",
            op_.VariableName());
  TFStatement(Call(op_.VariableName(), "Reset",
                   {op_.OpNameString(), "raw_device_name"}));
  TFStatement(Call("MaybeSetOpName", {op_.VariableName() + ".get()", "name"}));
  // Set each input
  for (const ArgView& ar : op_.Inputs()) {
    TFStatement(Call(op_.VariableName(), ar.SetterMethod(), ar.SetterArgs()));
  }

OpCommentRenderer::OpCommentRenderer(RendererContext context, OpView op)
    : Renderer(context), op_(op) {}

void OpCommentRenderer::Render() {
  if (context_.mode == RendererContext::kHeader) {
    // Add a short 1-line comment to the header files.
    CommentLine(op_.Summary());
    return;
  }

  CommentLine("Op: $0()", op_.FunctionName());
  CommentLine("Summary: $0", op_.Summary());
  CommentLine("");
  CommentLine("Description:");

                   std::make_move_iterator(args_with_default_val.end()));
  return absl::Substitute("$0 $1($2)", "Status", op_.FunctionName(),
                          absl::StrJoin(arguments, ", "));
}

OpRenderer::OpRenderer(RendererContext context, OpView op)
    : Renderer(context), op_(op), comment_(context, op) {}

void OpRenderer::Render() {
  comment_.Render();
  if (context_.mode == RendererContext::kHeader) {

namespace cpp {

OpView::OpView(OpSpec op)
    : op_(op),
      input_args_(op_.Inputs().begin(), op_.Inputs().end()),
      output_args_(op_.Outputs().begin(), op_.Outputs().end()),
      argument_attrs_(op_.Attributes().begin(), op_.Attributes().end()) {
  // Initialize function arguments
  all_arguments_.push_back(OpArgumentView("AbstractContext*", "ctx"));
  for (const auto& arg : op_.Inputs()) {

  void set_op(string op) {
    DCHECK(IsEmpty());
    op_ = std::move(op);
  }

  void set_assigned_device(string assigned_device) {
    DCHECK(IsEmpty());
    assigned_device_ = std::move(assigned_device);
  }

  void set_constant_value(Tensor constant_value) {
    DCHECK(IsEmpty());
    constant_value_ = std::move(constant_value);
    op_ = "Const";
  }

  void set_inputs(InputSeqMatcher inputs) {

// by cloning the root op to replicate that value. The old op will get folded.
def CloningOpResult : NativeCodeCall<
  "$_builder.clone(*op0)->getOpResult(0)">;

// Same as CloningOpResult but is used for ops with multiple results.
class CloningOpResults<int returns> : NativeCodeCall<
  "$_builder.clone(*op0)->getOpResults()", returns>;

// Creates an 1D array const with float values.
class Create1DConst<string values> : NativeCodeCall<

namespace generator {
namespace cpp {

class OpCommentRenderer : public Renderer {
 public:
  explicit OpCommentRenderer(RendererContext context, OpView op);

  void Render();

 private:
  OpView op_;
};

}  // namespace cpp
}  // namespace generator
}  // namespace tensorflow