[](mlir::OpPassManager& pm, llvm::StringRef options,
         llvm::function_ref<mlir::LogicalResult(const llvm::Twine&)>
             errorHandler) {
        tensorflow::PopulateLowerToMlProgramAndHloPipeline(pm);
        return mlir::success();
      },
      [](llvm::function_ref<void(const mlir::detail::PassOptions&)>) {});
}

                                << "\n     in " << use->get() << "\n");
      });
    });
  }

 private:
  llvm::function_ref<bool(tf_device::ClusterOp, ElementsAttr)> filter_;
};

}  // anonymous namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateClusterConstantSinkingPass(
    llvm::function_ref<bool(tf_device::ClusterOp, ElementsAttr)> filter) {
  return std::make_unique<ClusterConstantSinkingPass>(filter);
}

bool IsArgConsumedByFallback(mlir::func::FuncOp func, int arg_index);

void ForEachArgConsumedByFallback(
    mlir::func::FuncOp func, llvm::function_ref<void(int arg_index)> action);

void ForEachArgConsumedByFallback(
    mlir::ModuleOp module,
    llvm::function_ref<void(llvm::StringRef func_name, int arg_index)> action);

}  // namespace fallback_async
}  // namespace tfrt

}

void ForEachArgConsumedByFallback(
    mlir::func::FuncOp func, llvm::function_ref<void(int arg_index)> action) {
  for (int arg_index = 0; arg_index < func.getNumArguments(); ++arg_index) {
    if (IsArgConsumedByFallback(func, arg_index)) action(arg_index);
  }
}

void ForEachArgConsumedByFallback(
    mlir::ModuleOp module,
    llvm::function_ref<void(llvm::StringRef func_name, int arg_index)> action) {

  }
  static Derived getChecked(function_ref<InFlightDiagnostic()> emitError,
                            MLIRContext* context, ArrayRef<StringAttr> attrs) {
    return Base::getChecked(emitError, context, attrs);
  }

  static Derived get(MLIRContext* context) { return get({}, context); }

  // TODO(fengliuai): fix the implementation
  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,

// corresponding signature metadata populated in TFRTSavedModelSignatureInfo for
// the function.
Status MapFunctionSignaturesFromTFSavedModelMLIR(
    mlir::ModuleOp module,
    llvm::function_ref<void(const TFRTSavedModelSignatureInfo&)> map_fn);

}  // namespace tensorflow

// and returns a `mlir::WalkResult::interrupt()` when it encounters a call whose
// callee cannot be resolved to `mlir::func::FuncOp`.
mlir::WalkResult WalkReachableFunctions(
    mlir::func::FuncOp func,
    llvm::function_ref<mlir::WalkResult(mlir::func::FuncOp)> callback,
    mlir::SymbolTableCollection* symbol_table = nullptr);

// Creates a new MLIR module that contains only the given functions and all
// reachable functions from them.

// must also be in extra_dependencies(op1, false).
// This function is called multiple times during the topological sort,
// so the implementation should preferably be constant-time.
typedef llvm::function_ref<llvm::SmallVector<Operation *, 4> const &(
    Operation *, bool incoming)>
    ExtraDependenciesFunction;

// Convenience function if there are no extra dependencies to declare.

#include "mlir/IR/Visitors.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project

namespace mlir {
namespace TF {

WalkResult WalkReachableFunctions(
    func::FuncOp func,
    llvm::function_ref<WalkResult(func::FuncOp)> callback,
    SymbolTableCollection* symbol_table) {
  llvm::SmallDenseSet<Operation*> visited;

  llvm::SmallVector<func::FuncOp> stack;
  stack.push_back(func);

// `infer_from_user` should check if the provided op is an accessing op that
// could be used to infer the type.
std::optional<RankedTensorType> GetElementTypeFromAccess(
    Value collection, ModuleOp module,
    llvm::function_ref<std::optional<Type>(Operation*)> infer_from_op);

// Creates a ReadVariableOp on a local variable.
Value ReadLocalVariable(Value local_var, OpBuilder builder, Location loc);