}

TEST_F(GetInputValuesTest, RequestContainsNoInputs) {
  google::protobuf::Map<std::string, TensorProto> local_request = request_;
  local_request.erase("x");
  local_request.erase("y");

  std::vector<std::pair<string, Tensor>> inputs;
  TF_EXPECT_OK(GetInputValues(sig_, local_request, inputs));

  std::vector<std::pair<string, TensorProto>> exp_inputs;

  scalar_tensor.scalar<float>()() = 0.0f;
  auto flow = builder.create<TF::ConstOp>(
      ta.getLoc(), tensorflow::ConvertTensor(scalar_tensor, &builder).value());
  ta.getFlow().replaceAllUsesWith(flow);
  ta.erase();
  (*stats)[local_var].accumulate_on_write = false;
  return success();
}

LogicalResult HandleTensorArrayReadV3Op(
    TF::TensorArrayReadV3Op read,

      it.first->eraseOperands(it.second);
    }

    func.eraseArguments(args_to_erase);
  }

  // Erase all global tensors that were frozen.
  for (auto global_tensor : frozen_global_tensors) {
    remaining_global_tensor_ops.erase(global_tensor);
    global_tensor->erase();
  }

  // Verify that there are no remaining global tensors.
  if (!allow_mutable_tensors && !remaining_global_tensor_ops.empty()) {

    // Updates usage and erases rewritten reduce_dataset op based on the number
    // of state variables.
    for (int i = 0; i < state_size; ++i) {
      reduce_dataset.getResult(i).replaceAllUsesWith(
          dataset_while.getResult(i + 1));
    }
    reduce_dataset.erase();

    return WalkResult::advance();
  });

  }

  // Relocate the main function's FetchOp to the last.
  main_body.push_back(main_fetch_op->clone(mapper));
  main_fetch_op.erase();

  auto cloned_fetch_op = cast<FetchOp>(src_graph_op.GetFetch()->clone(mapper));
  Value control_fetch = *cloned_fetch_op.getFetches().begin();
  cloned_fetch_op.erase();

  return control_fetch;
}

// Creates a new `IdentityOp` wrapped by an `IslandOp`. The identity op returns

    if (failed(LiftHashTableOpsToArguments(module_op, caller_func))) {
      return failure();
    }
  }

  // Erase the lifted operations explicitly.
  for (auto [lifted_op, arg_idx] : lifted_op_and_arg_idx) {
    lifted_op->erase();
  }

  return success();
}

void LiftHashTableOpsAsArgsPass::runOnOperation() {
  auto module_op = getOperation();

  for (const auto& fetch : llvm::enumerate(graph_op.GetFetch().getFetches())) {
    if (fetch.value() == island_op.getControl()) {
      graph_op.GetFetch().getFetchesMutable().erase(fetch.index(), 1);
      break;
    }
  }
  island_op.erase();
}

std::unique_ptr<OperationPass<func::FuncOp>> CreateSplitIntoIslandPerOpPass() {
  return std::make_unique<TF::SplitIntoIslandPerOpPass>();
}

}  // namespace TF

  // reinserted into the cache in UpdateLRU.
  entry->second->timestamp = 0;
  lru_list_.erase(entry->second->lru_iterator);
  lra_list_.erase(entry->second->lra_iterator);
  cache_size_ -= entry->second->data.capacity();
  block_map_.erase(entry);
}

        assert(replicated_input->use_empty());
        replicated_input->erase();
        return WalkResult::advance();
      });

  if (result.wasInterrupted()) {
    signalPassFailure();
    return;
  }

  getOperation()->walk([](TF::TPUPartitionedInputV2Op partitioned_input) {
    if (partitioned_input->use_empty()) partitioned_input->erase();
  });
}

}  // namespace

)

var _ Informer[runtime.Object] = informer[runtime.Object]{}

type informer[T runtime.Object] struct {
	cache.SharedIndexInformer
	lister[T]
}

// Creates a generic informer around a type-erased cache.SharedIndexInformer
// It is incumbent on the caller to ensure that the generic type argument is
// consistent with the type of the objects stored inside the SharedIndexInformer
// as they will be casted.