bool would_be_cloned,
                       mlir::IRMapping &mapping) const final {
    // All tf_mlrt dialect ops can be inlined.
    return true;
  }
  // Note that CallOp and ReturnOp are handled by func; so need to implement
  // handleTerminator.
};

}  // namespace

TensorflowMlrtDialect::TensorflowMlrtDialect(mlir::MLIRContext *context)

// to functions).
bool IsAlreadyOutlined(WhileOp while_op) {
  auto just_call = [](Region& region) {
    auto it = region.front().begin();
    if (!isa<func::CallOp>(*it)) return false;
    ++it;
    if (!isa<YieldOp>(*it)) return false;
    return true;
  };
  return just_call(while_op.getBody()) && just_call(while_op.getCond());
}

    // the op using the builder.
    CPred<"ArgTypesMatchCallee(&*$_builder.getInsertionPoint(), $1, $2)">>;

foreach callOp = [TF_PartitionedCallOp, TF_StatefulPartitionedCallOp] in {
  def : Pat<(callOp:$op $args, FlatSymbolRefAttr:$f,
             $config, $config_proto, $executor_type),
            (CallOp $f, $args),
          [(ArgTypesMatchCallee $op, $args, $f)]>;
}

                                         while_region.getBody()));
    } else if (auto case_op = dyn_cast<CaseOp>(op)) {
      llvm::SmallVector<func::FuncOp, 4> functions;
      case_op.get_branch_functions(functions);
      AnalyzeFunctionalCaseOrIfOp(case_op, functions, backtrack_analysis);
    } else if (auto if_op = dyn_cast<IfOp>(op)) {
      AnalyzeFunctionalCaseOrIfOp(

// uses `get_next` to get the next value and calls `reduce_func`.  `body_args`
// is used as pass through of state values for else branch.  `dataset_types` is
// used for constructing the CallOp for `reduce_func`.
IfRegionOp CreateOptionalDatasetIf(
    OpBuilder builder, ReduceDatasetOp reduce_dataset, FuncOp reduce_func,
    IteratorGetNextAsOptionalOp get_next, OptionalHasValueOp optional_has_value,

          op, {if_op.then_function(), if_op.else_function()}, if_op.getInput());
    } else if (auto case_op = dyn_cast<TF::CaseOp>(op)) {
      SmallVector<func::FuncOp, 4> branches;
      case_op.get_branch_functions(branches);
      result =
          CanonicalizeFunctionalIfCase(case_op, branches, case_op.getInput());
    } else if (auto while_op = dyn_cast<TF::WhileOp>(op)) {

  PopulateLegalizeHloToTFLitePatterns(&patterns, &context);

  ConversionTarget target(context);
  target.addLegalDialect<TFL::TensorFlowLiteDialect, mhlo::MhloDialect>();
  target.addLegalOp<func::CallOp, func::ConstantOp, arith::ConstantOp>();
  target.addDynamicallyLegalOp<mhlo::CustomCallOp>(IsCustomCallLegal);
  target.addDynamicallyLegalOp<mhlo::ReduceOp>(IsReduceOpLegal);

  target.addLegalDialect<arith::ArithDialect>();
  target.addLegalDialect<func::FuncDialect>();
  target.addLegalDialect<tensor::TensorDialect>();
  target.addLegalDialect<shape::ShapeDialect>();
  target.addLegalOp<func::CallOp>();

  if (skip_quantization_ops_) {
    target.addLegalOp<TF::FakeQuantWithMinMaxVarsOp>();
    target.addLegalOp<TF::FakeQuantWithMinMaxVarsPerChannelOp>();
    target.addLegalOp<TF::FakeQuantWithMinMaxArgsOp>();

// that result if so. Otherwise, it will clone and convert the callee function,
// and performs stack ops decomposition on it.
template <typename CallOp>
LogicalResult HandlePartitionedCallOp(
    CallOp call, func::FuncOp callee, ModuleOp module,
    const llvm::SmallDenseMap<Value, Value>& data_var_to_size_var,
    llvm::StringMap<PartitionedCallStackOpsInfo>*

      if (!fold_all_constants_flag_) {
        if (!IsConstOrQConstInt(op)) return;
      }

      for (auto consumer : op->getResult(0).getUsers()) {
        auto consumer_call = llvm::dyn_cast_or_null<func::CallOp>(consumer);

        if (!consumer_call) continue;

        auto function_name = consumer_call.getCallee();

        // Locate the argument position of the use.
        int argument_index = -1;