MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LegalizeTFToQuant)

  explicit LegalizeTFToQuant() = default;
  LegalizeTFToQuant(const LegalizeTFToQuant &) {}

  /// Performs the lowering to Quant ops dialect.
  void runOnOperation() override;

  void getDependentDialects(DialectRegistry &registry) const override {
    registry.insert<quant::QuantizationDialect,
                    quantfork::QuantizationForkDialect>();
  }

  }

  Option<bool> use_test_setting_{
      *this, "use-test-setting",
      llvm::cl::desc(
          "Whether to use the test config for the tac filter protobuf."),
      llvm::cl::init(false)};

  void runOnOperation() override;
};

void ApplyFunctionTacFilter(func::FuncOp func,
                            FunctionFilter::FunctionFilterType type,
                            OpBuilder& builder) {

#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_device_passes.h.inc"

struct DecomposeResourceOpsPass
    : public impl::DecomposeResourceOpsPassBase<DecomposeResourceOpsPass> {
  void runOnOperation() override {
    // Add lowering patterns to the list.
    RewritePatternSet patterns(&getContext());
    TF::PopulateDecomposeResourceOpsPatterns(&getContext(), &patterns);

#define GEN_PASS_DEF_BROADCASTFOLDPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

class BroadcastFoldPass
    : public impl::BroadcastFoldPassBase<BroadcastFoldPass> {
 public:
  void runOnOperation() override;
};

LogicalResult ConvertResultsBroadcastableShapeOp::matchAndRewrite(
    Operation* op, PatternRewriter& rewriter) const {
  if (op->hasTrait<OpTrait::ResultsBroadcastableShape>())

#define GEN_PASS_DEF_GROUPBYDIALECTPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

class GroupByDialectPass
    : public impl::GroupByDialectPassBase<GroupByDialectPass> {
 public:
  void runOnOperation() override;

 private:
  void processFunction(mlir::func::FuncOp func, int& counter,
                       llvm::SmallDenseSet<StringRef>& dialects,
                       Operation* module);

    return "quant-propagate-quantize-type";
  }
  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Propagate quantized type through allowed ops.";
  }

  void runOnOperation() override;
};

// Propagate dequantize op if the next op supports the data type.
// Given the below graph,
// op_before_dequantize -> dequantize_op -> user_op -> rest_op

#define GEN_PASS_DEF_LOWERQUANTIZEDPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

class LowerQuantizedPass
    : public impl::LowerQuantizedPassBase<LowerQuantizedPass> {
 public:
  void runOnOperation() override {
    RewritePatternSet patterns(&getContext());
    mlir::TF::PopulateLoweringQuantizedPatterns(&getContext(), &patterns);
    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
  }
};

// Lowers some of the TensorFlow operations that can be represented using other
// TensorFlow operations.
struct LowerTF : public impl::TestTensorFlowLowerTFPassBase<LowerTF> {
  void runOnOperation() override {
    // Add lowering patterns to the list.
    RewritePatternSet patterns(&getContext());
    if (default_patterns_) {
      mlir::TF::PopulateLoweringTFPatterns(&getContext(), &patterns);
    }

    this->fold_all_constants_flag_ = other.fold_all_constants_flag_;
  }
  explicit FoldConstantsToSubgraphPass(bool fold_all_constants) {
    fold_all_constants_flag_ = fold_all_constants;
  }

 private:
  void runOnOperation() override;

  Option<bool> fold_all_constants_flag_{
      *this, "fold-all-constants",
      llvm::cl::desc("Whether to fold all constants or just i32."),
      llvm::cl::init(false)};
};

                               const int bit_width) {
    enable_per_channel_quantized_weight_ = enable_per_channel_quantized_weight;
    bit_width_ = bit_width;
  }

  void runOnOperation() override;
};

// Merges consecutive QuantizeCast ops. See b/246655213 for details.
// For example, the following case:
// %1 = quantfork.QuantizeCastOp(%0) : f32 -> qtype1