// Perform tf.data optimizations.
struct TFDataOptimization
    : public impl::TFDataOptimizationPassBase<TFDataOptimization> {
  void runOnOperation() override {
    RewritePatternSet patterns(&getContext());
    mlir::TF::PopulateTFDataOptimizationPatterns(&getContext(), &patterns);

    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
  }
};

}  // namespace

                                              MLIRContext *context) {
  results.add<RemoveRedundantGetLength>(context);
}

void BuildListOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                              MLIRContext *context) {
  results.add<BuildConstantListAsAttr>(context);
}

void TFRQuantRawDataOp::getCanonicalizationPatterns(RewritePatternSet &results,

  explicit UnfuseMhloBatchNormPass() = default;

 private:
  void runOnOperation() override;
};

void UnfuseMhloBatchNormPass::runOnOperation() {
  MLIRContext* ctx = &getContext();
  RewritePatternSet patterns(ctx);
  mhlo::populateUnfuseBatchNormPatterns(ctx, &patterns);

  if (failed(
          applyPatternsAndFoldGreedily(getOperation(), std::move(patterns)))) {
    return signalPassFailure();
  }
}

namespace mlir {
namespace TFL {
namespace tac {

class ExampleHardware : public SimpleHardware {
 public:
  static constexpr char kId[] = "ExampleHardware";

  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override;

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<ExampleHardware>();
  }

namespace mlir {
namespace TFL {
namespace tac {

class NNAPIHardware : public SimpleHardware {
 public:
  static constexpr char kId[] = "NNAPI";

  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override;

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<NNAPIHardware>();
  }

namespace TFR {

// Scans the func op and adds all the canonicalization patterns of the ops
// except the tf ops, inside the function.
void populateCanonicalizationPatterns(func::FuncOp func,
                                      RewritePatternSet &patterns);

// Decompose ops.
std::unique_ptr<OperationPass<func::FuncOp>> CreateDecomposeTFOpsPass(
    std::optional<ModuleOp> tfr_module = std::nullopt);

                                RewritePatternSet* patterns);

// Populates TF to MHLO legalization for some of the quantization ops.
//
// TODO(hinsu): Remove this once we combine quantized and non quantized op
// legalization in the ODML conversion pipeline.
void PopulateLegalizeTfQuantizationPatterns(MLIRContext* context,
                                            RewritePatternSet* patterns);

// which automatically locks all resource variables.
void PopulateDecomposeResourceOpsPatterns(MLIRContext *context,
                                          RewritePatternSet *patterns);

}  // namespace TF
}  // namespace mlir

LogicalResult BatchMatMulV2Op::verify() { return Verify(*this); }

void BatchMatMulOp::getCanonicalizationPatterns(RewritePatternSet& results,
                                                MLIRContext* context) {
  results.add<BatchMatMulToV2>(context);
}

void BatchMatMulV2Op::getCanonicalizationPatterns(RewritePatternSet& results,
                                                  MLIRContext* context) {

  void runOnOperation() override;
};

#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/bridge/optimize.inc"

void OptimizeIntGraph::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  populateWithGenerated(patterns);
  auto func = getOperation();
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    signalPassFailure();
  }
}