}

def BatchMatMulToEinsumPass : Pass<"tf-batch-matmul-to-tf-einsum", "mlir::func::FuncOp"> {
  let summary = "Replace TF BatchMatMul op by TF Einsum op.";
  let constructor = "TF::CreateBatchMatMulToEinsumPass()";
}

def CanonicalizeCompileAndReplicateAttributesPass : Pass<"tf-canonicalize-compile-and-replicate-attributes", "mlir::func::FuncOp"> {
  let summary = "Canonicalize compilation and replication attributes.";

  void EnqueueCallers(func::FuncOp fn);

  // Returns the function at the front of the queue.
  func::FuncOp front() { return queue_.front(); }

  // Returns whether work queue is empty.
  bool EmptyQueue() const { return queue_.empty(); }

  // Returns function from the front of the work queue.
  func::FuncOp pop_front() {
    func::FuncOp ret = queue_.front();
    queue_.pop();

  // Mark main function public, others private.
  for (auto function : module.get().getOps<mlir::func::FuncOp>()) {
    auto visibility = function.getName() == graph_func_name
                          ? mlir::func::FuncOp::Visibility::Public
                          : mlir::func::FuncOp::Visibility::Private;
    function.setVisibility(visibility);
  }
  VLOG(2) << "Imported: "

  named_regions.reserve(std::distance(module_.begin(), module_.end()));

  int subgraph_idx = 0;

  // Entry functions for signature defs.
  std::vector<FuncOp> entry_functions;
  std::vector<FuncOp> non_entry_functions;
  FuncOp main_fn = module_.lookupSymbol<FuncOp>("main");
  if (main_fn != nullptr) {
    // Treat the main function as a signature def when the given main function

}

LogicalResult WhileOp::verifySymbolUses(SymbolTableCollection &symbol_table) {
  auto cond_fn =
      symbol_table.lookupNearestSymbolFrom<func::FuncOp>(*this, getCondAttr());
  auto body_fn =
      symbol_table.lookupNearestSymbolFrom<func::FuncOp>(*this, getBodyAttr());
  if (!cond_fn) {
    return emitOpError("cond refers to an undefined function : ") << getCond();
  }
  if (!body_fn) {

LogicalResult BatchFunctionOp::verifySymbolUses(
    SymbolTableCollection& symbolTable) {
  StringAttr func_attr = getFAttr().getRootReference();
  func::FuncOp func =
      symbolTable.lookupNearestSymbolFrom<func::FuncOp>(*this, func_attr);

  if (!func) {
    return emitError("'f' attribute refers to an undefined function: ")
           << func_attr.getValue();
  }

  return success();
}

        dimension_numbers.getOutputFeatureDimension(),
        dimension_numbers.getOutputSpatialDimensions());
  }
};

void UniformQuantizedStableHloToTflPass::runOnOperation() {
  func::FuncOp func_op = getOperation();
  MLIRContext& ctx = getContext();

  RewritePatternSet patterns(&ctx);
  patterns.add<RewriteHybridQuantizedConvolutionOp,

std::unique_ptr<OperationPass<func::FuncOp>> CreateOptimizePass(
    bool enable_canonicalization, bool disable_fuse_mul_and_fc) {
  return std::make_unique<OptimizePass>(enable_canonicalization,
                                        disable_fuse_mul_and_fc);
}

std::unique_ptr<OperationPass<func::FuncOp>> CreateOptimizePass() {
  return std::make_unique<OptimizePass>();
}

    if (called_computations.size() != 1) {
      return op.emitOpError()
             << "ApproxTopK takes exactly 1 called_computation.";
    }
    mlir::func::FuncOp callee = module_op_->lookupSymbol<mlir::func::FuncOp>(
        mlir::cast<FlatSymbolRefAttr>(op.getCalledComputations()[0]));
    mlir::FunctionType callee_type = callee.getFunctionType();
    SmallVector<Type, 4> expected_callee_input_types;

    /// and result type.
    static bool isBuildableWith(Attribute value, Type type);
  }];
}

def TFL_ControlNodeOp : Op<TFL_Dialect, "control_node",
    [HasParent<"mlir::func::FuncOp">, RecursiveMemoryEffects, SingleBlockImplicitTerminator<"YieldOp">]> {
  let summary = [{
    The `TFL.control_node` operation wraps single-block operations in order to attach control edges.
  }];