to_remove.push_back(init_func_op);
      } else {
        to_keep.push_back(sym_ref);
      }
    }

    for (auto func_op : to_remove) rewriter.eraseOp(func_op);

    if (to_keep.empty())
      rewriter.eraseOp(op);
    else
      op->setAttr("initializers", rewriter.getArrayAttr(to_keep));

    return success();
  }
};

void SessionInitializerOp::getCanonicalizationPatterns(

      if ((custom_op_map.find(op_name) == custom_op_map.end()) ||
          !custom_op_map.find(op_name)->second.no_side_effect)
        return failure();
    }
    rewriter.eraseOp(op);
    return success();
  }
  quant::CustomOpMap custom_op_map;
};

#include "tensorflow/compiler/mlir/lite/transforms/generated_post_quantize.inc"

void PostQuantizePass::runOnOperation() {

    rewriter.replaceAllUsesWith(assign_group.getResult(0), const_group_size);
    rewriter.replaceAllUsesWith(assign_group.getResult(1), const_group_key);
    rewriter.eraseOp(assign_group);
    return success();
  }
};

void LegalizeTFCollective::runOnOperation() {
  // FIXME(b/226139061): Figure out a way to share the channel_id with

      return failure();

    for (auto &use : llvm::make_early_inc_range(op.getControl().getUses()))
      use.getOwner()->eraseOperand(use.getOperandNumber());

    rewriter.eraseOp(op);

    return success();
  }
};

// This pattern matches and removes IslandOps with no inner ops, no control
// operands, one data result and no control result user. The single data result

  return failure();
}

// TF Lite doesn't support Assert, we just drop the assert from the graph.
LogicalResult ConvertTFAssertOp::matchAndRewrite(
    Operation* op, PatternRewriter& rewriter) const {
  rewriter.eraseOp(op);
  return success();
}

// Legalize unidirectional sequence lstm.
struct LegalizeUnidirectionalSequenceLstm : public RewritePattern {
  explicit LegalizeUnidirectionalSequenceLstm(MLIRContext* context)

  func_op.eraseArguments(args_to_erase_bit_vector);

  // Erases entries in "tf._input_shapes" attribute of `func_op` that correspond
  // to the erased arguments.
  if (auto input_shapes_attr =
          func_op->getAttrOfType<ArrayAttr>(kTfInputShapesAttr);
      input_shapes_attr) {
    // Construct a new array of input shapes excluding the input shapes of the
    // erased arguments.
    SmallVector<Attribute> updated_input_shapes_attr;

      CreateRemoteRunCalls(context, *metadatas);

      // Erases the original operations which have been cloned in the remote
      // functions.
      for (auto &iter : *metadatas) {
        llvm::StringRef host = iter.first();
        FunctionMetadata &metadata = iter.second;
        // Do not erase operations placed on the localhost.
        if (IsOnLocalHost(host)) continue;

  while (!control_barrier_worklist.empty()) {
    Value control_barrier = control_barrier_worklist.front();
    control_barrier_worklist.pop();

    // We can only erase control barriers whose uses have been erased as well.
    if (!control_barrier.use_empty()) continue;

    // Only values defined by IslandOp were inserted in the worklist.

  // corresponding VarHandleOps.
  CreateAssignVariableOps(const_op_name_map, session_init_func);

  // Erase the ConstOps that are replaced by VarHandleOps.
  absl::c_for_each(target_const_ops, [](auto const_op) { const_op.erase(); });
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateUnfreezeConstantsPass() {
  return std::make_unique<UnfreezeConstantsPass>();

   * are valid.
   *
   * @param rowKey row key of mapping to be erased
   * @param columnKey column key of mapping to be erased
   * @return the value previously associated with the keys, or {@code null} if no mapping existed
   *     for the keys
   */
  @CanIgnoreReturnValue
  @CheckForNull
  public V erase(@CheckForNull Object rowKey, @CheckForNull Object columnKey) {