Value value,
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>&
        effects) {
  if (value.getType().cast<TensorType>().getElementType().isa<ResourceType>()) {
    effects.emplace_back(MemoryEffects::Read::get(), value,
                         ResourceEffects::Variable::get());
    effects.emplace_back(MemoryEffects::Write::get(), value,
                         ResourceEffects::Variable::get());
  }

void MarkResourceAsReadAndWrite(
    Value value,
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>&
        effect);

void MarkResourceAsReadOnly(
    Value value,
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>&
        effect);

}  // namespace TF
}  // namespace mlir

// depends on them.
def TF_GeneratorOpSideEffect : MemoryEffects<[MemWrite<TF_GeneratorOpResource>]>;

def TF_TPUEmbeddingWriteEffect : MemoryEffects<[MemWrite<TF_TPUEmbeddingResource>]>;
def TF_TPUEmbeddingReadEffect : MemoryEffects<[MemRead<TF_TPUEmbeddingResource>]>;

def TF_SendSideEffect : MemoryEffects<[MemWrite<TF_SendResource>]>;
def TF_RecvSideEffect : MemoryEffects<[MemWrite<TF_RecvResource>]>;

SideEffects GetSideEffectsFromEffectInstance(
    const MemoryEffects::EffectInstance& effect_instance, Operation* op) {
  mlir::SideEffects::Effect* effect = effect_instance.getEffect();
  SideEffects side_effects;
  if (isa<MemoryEffects::Allocate>(effect)) {
    side_effects.SetAlloc();
  } else if (isa<MemoryEffects::Free>(effect)) {
    side_effects.SetFree();
  } else if (isa<MemoryEffects::Read>(effect)) {
    side_effects.SetRead();

//===----------------------------------------------------------------------===//

void TPUExecuteOp::getEffects(
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
        &effects) {
  effects.reserve(2 * getArgs().size() + 1);
  effects.emplace_back(MemoryEffects::Write::get(),
                       ResourceEffects::TPUExecute::get());

  // Conservatively mark resource handles as read and write, as without

}

bool OnlyHasReadEffect(Operation *op) {
  auto interface = llvm::dyn_cast<MemoryEffectOpInterface>(op);
  if (!interface) return false;
  return interface.onlyHasEffect<MemoryEffects::Read>();
}

// Get read only variable handles in `func`.
llvm::DenseSet<ResourceHandle> GetReadOnlyVariables(func::FuncOp func) {
  llvm::DenseMap<ResourceHandle, llvm::SmallVector<Operation *, 4>> resources;

// `ops_to_preserve_ids_` or if it has a `MustExecute` effect.
bool GraphPruningPass::ShouldPreserveOp(Operation* op) {
  if (ops_to_preserve_ids_.contains(op->getName().getIdentifier())) return true;

  llvm::SmallVector<MemoryEffects::EffectInstance, 4> effects;
  auto interface = dyn_cast<MemoryEffectOpInterface>(op);
  if (interface) interface.getEffects(effects);

  for (const auto& effect : effects) {

  if (!mem_interface) return false;

  for (Value value : filter_resources(op->getResults())) {
    llvm::SmallVector<MemoryEffects::EffectInstance, 4> effects;
    mem_interface.getEffectsOnValue(value, effects);
    for (auto& effect_instance : effects) {
      if (isa<MemoryEffects::Allocate>(effect_instance.getEffect())) {
        return true;
      }
    }
  }
  return false;
}

}  // namespace

          TensorFlowRegistryEffectInterfaceFallback> {
  static bool classof(Operation *op) { return true; }
  void getEffects(
      Operation *op,
      SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
          &effects) const {}
};

void *TensorFlowDialect::getRegisteredInterfaceForOp(
    mlir::TypeID interface, mlir::OperationName opName) {