#include <string_view>
#include <utility>

#include "absl/strings/str_cat.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/Dialect/Quant/QuantOps.h"  // from @llvm-project
#include "mlir/Dialect/Shape/IR/Shape.h"  // from @llvm-project
#include "mlir/IR/Builders.h"  // from @llvm-project
#include "mlir/IR/BuiltinAttributes.h"  // from @llvm-project

#ifndef TFL_OP_INTERFACES
#define TFL_OP_INTERFACES

include "mlir/IR/OpBase.td"

def TFL_Dialect : Dialect {
  let name = "tfl";

  let description = [{
    The TensorFlow Lite dialect.

    This dialect maps to TensorFlow Lite operations.

    Invariants:

    * All values are of Tensor type (in particular, scalars are

//===----------------------------------------------------------------------===//
//
// Predicates for types in the Quantization dialect.
//
//===----------------------------------------------------------------------===//

#ifndef QUANT_FORK_BASE
#define QUANT_FORK_BASE

include "mlir/IR/OpBase.td"

def QuantizationFork_Dialect : Dialect {
  let name = "quantfork";
  let cppNamespace = "::mlir::quantfork";
}

//===----------------------------------------------------------------------===//
//
// Predicates for types in the Quantization dialect.
//
//===----------------------------------------------------------------------===//

#ifndef QUANTIZATION_BASE
#define QUANTIZATION_BASE

include "mlir/IR/OpBase.td"

def Quant_Dialect : Dialect {
  let name = "quantization";
  let cppNamespace = "::mlir::quant::ir";
}

#include "absl/status/statusor.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project  // IWYU pragma: keep
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "mlir/IR/MLIRContext.h"  // from @llvm-project
#include "mlir/Pass/Pass.h"  // from @llvm-project  // IWYU pragma: keep
#include "mlir/Support/TypeID.h"  // from @llvm-project
#include "stablehlo/dialect/StablehloOps.h"  // from @stablehlo  // IWYU pragma: keep

  if (pass_config.enable_composite_direct_lowering) {
    pass_manager.addPass(mlir::odml::CreateCompositeLoweringPass());
  }

  // TFLite dialect passes.
  if (!pass_config.disable_hlo_to_tfl_conversion) {
    pass_manager.addPass(mlir::odml::CreateLegalizeHloToTfLitePass());
  }
  // TF dialect passes
  pass_manager.addPass(mlir::odml::CreateLegalizeHloToTfPass());

  // folds tf.BroadcastTo ops with subsequent ops if they have built in

CreateHoistReplicateInvariantResourceWritesPass();

// Transforms functional control flow operations in the TensorFlow dialect to
// MLIR Control Flow Graph (CFG) form.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateTFFunctionalControlFlowToCFG();

// Transforms functional control flow operations in the TensorFlow dialect to
// their region based counterparts.
std::unique_ptr<OperationPass<ModuleOp>>
CreateTFFunctionalControlFlowToRegions();

#define GET_OP_CLASSES
#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/tf_quant_ops.cc.inc"

namespace mlir {
namespace quant {

void RegisterOpsHook(TF::TensorFlowDialect &dialect) {
  dialect.addOperations<
#define GET_OP_LIST
#include "tensorflow/compiler/mlir/quantization/tensorflow/passes/tf_quant_ops.cc.inc"
      >();
}

void RegisterOps() {

#ifndef TENSORFLOW_COMPILER_MLIR_LITE_UTILS_CONSTANT_UTILS_H_
#define TENSORFLOW_COMPILER_MLIR_LITE_UTILS_CONSTANT_UTILS_H_

#include "mlir/Dialect/Arith/IR/Arith.h"  // from @llvm-project
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
#include "mlir/IR/Location.h"  // from @llvm-project

#define TENSORFLOW_COMPILER_MLIR_LITE_TRANSFORMS_LIFT_TFLITE_FLEX_OPS_H_

#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/Pass/Pass.h"  // from @llvm-project

namespace mlir {
namespace TFL {

// Creates an instance of the lift TFLite Flex ops pass that lifts TFLite Flex
// ops into TF dialect operations.
std::unique_ptr<OperationPass<func::FuncOp>> CreateLiftTfliteFlexOpsPass();