// above may invalidate previously inserted islands mid-loop.
  for (MergedIsland& island : merged_islands_)
    island_to_merged_island_.try_emplace(island.insert_point, &island);

  // This functor merges the given `old_merged_island` into the
  // `new_merged_island`. `merge_in_front` is whether the old island should be
  // merged into the front of the new island, or the back.

 * java.util.function.Function java.util.function.Function}.
 *
 * <p>The {@link Functions} class provides common functions and related utilities.
 *
 * <p>See the Guava User Guide article on <a
 * href="https://github.com/google/guava/wiki/FunctionalExplained">the use of {@code Function}</a>.
 *
 * <h3>For Java 8+ users</h3>
 *

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "tensorflow/compiler/mlir/tfrt/function/function.h"

#include "absl/log/log.h"
#include "absl/strings/match.h"
#include "mlir/IR/OperationSupport.h"  // from @llvm-project
#include "mlir/Pass/PassManager.h"  // from @llvm-project

  // to proactively transfer the result to host since the consumer op (or
  // function) of the result may still be on TPU.
  // TODO(b/194081364): remove this option once we unify servo TPU serving
  // result transfer behavior.
  bool tpu_transfer_result_to_host = false;
};

// Compile MLIR generated by tf.function in TF dialect into BEF.
Status CompileTFMLIRToBEF(const TfrtFunctionCompileOptions& options,

        continue;
      }

      return symbol_use.getUser()
          ->emitError("exported function cannot be internally referenced")
          .attachNote(func.getLoc())
          .append("references this exported function");
    }
  }
  return success();
}

LogicalResult VerifyExportedFunc(func::FuncOp func) {
  bool reached_bound_inputs = false;
  auto module = func->getParentOfType<ModuleOp>();

  return IsPureFunction(func_op);
}

bool OpSideEffectCollector::IsPureFunction(func::FuncOp func_op) const {
  auto it = is_pure_function_.find(func_op);
  if (it == is_pure_function_.end()) {
    bool is_pure = true;
    is_pure_function_[func_op] = is_pure;  // prevent infinite recursion
    func_op->walk([&](Operation* op) {
      if (op == func_op) {
        return WalkResult::advance();
      }

  std::vector<Type> output_types = GetValueTypes(outputs);
  builder.setInsertionPointToEnd(&module.getBodyRegion().back());
  func::FuncOp func_op = builder.create<func::FuncOp>(
      module.getLoc(), name,
      builder.getFunctionType(input_types, output_types));
  func_op.setPrivate();

  return func_op;
}

TF::StatefulPartitionedCallOp EncapsulateOpsInFunc(
    OpBuilder& builder, const llvm::SetVector<Operation*>& ops,

  assert(cost_map_.count(op) > 0);
  return cost_map_.lookup(op);
}

void CostAnalysis::AnalyzeArguments(mlir::func::FuncOp func_op) {
  // Use the max size among function inputs as the default size of dynamic
  // shaped tensors in the function.
  for (auto arg : func_op.getArguments()) {
    if (!mlir::isa<mlir::TensorType>(arg.getType())) continue;
    auto type = mlir::cast<mlir::TensorType>(arg.getType());

//   correct execution).
class SideEffectAnalysisInfo {
 public:
  SideEffectAnalysisInfo() = default;

  // Constructs analysis info by analyzing the given function.
  SideEffectAnalysisInfo(func::FuncOp func_op,
                         const OpSideEffectCollector& op_side_effect_collector,
                         const TF::ResourceAliasAnalysis::Info& alias_analysis,

  func::FuncOp partition_op;
};

// Returns a map that maps the host address to the metadata of the function
// for that remote host. The metadata of the function specifies the input
// values, result values, result devices and the operations to be included in
// the function body.
std::optional<llvm::StringMap<FunctionMetadata>> GetFunctionMetadatas(
    func::FuncOp func_op) {
  llvm::StringMap<FunctionMetadata> metadatas;