fun from(string: String) =
            ProgramText(string.replace("\r\n", "\n"))
    }

    internal
    fun erase(ranges: List<IntRange>): ProgramText =
        if (ranges.isEmpty()) this
        else ProgramText(text.erase(ranges))

    fun preserve(vararg ranges: IntRange): ProgramText =
        erase(complementOf(ranges))

    internal
    fun preserve(ranges: List<IntRange>): ProgramText =

     */
    AnsiContext newLines(int numberOfNewLines);

    /**
     * @return the current context with the characters moving forward from the write position erased.
     */
    AnsiContext eraseForward();

    /**
     * @return the current context with the entire line erased.
     */
    AnsiContext eraseAll();

    /**
     * @return the current context moved to the specified position.
     */

              new_q_op.getResult());
          assign_variable_op->replaceAllUsesWith(new_assign_variable_op);
        }
        assign_variable_op.erase();
        dq_op.erase();
      } else {
        // Add quantize op.
        builder.setInsertionPoint(assign_variable_op);
        auto new_q_op = builder.create<QuantizeOp>(
            assign_variable_op.getLoc(), ref_qtype,

      builder.create<mlir::ml_program::GlobalStoreOp>(op.getLoc(), sym,
                                                      op.getValue());
      op.erase();
    });
    if (!success) return failure();

    // Erase tf_saved_model attributes we consumed. We can't delete them
    // right away, since they might weave through blocks, but we can replace
    // them with a dummy which DCE can pick up later.

                          /* shouldCloneInlinedRegion = */ false))) {
      call_op.emitOpError() << "Failed to inline\n";
      return WalkResult::interrupt();
    }
    called_func.erase();
    call_op.erase();
    return WalkResult::advance();
  });
  if (walk_result.wasInterrupted()) return signalPassFailure();
  // Move all remaining nested functions back into the parent module.

          assert(user->use_empty());
          user->erase();
        }
      }
    }

    for (auto operand : cluster.getOperands()) {
      mlir::Operation* def = operand.getDefiningOp();
      if (operand.hasOneUse() &&
          llvm::isa_and_nonnull<mlir::TF::TPUPartitionedInputV2Op>(def)) {
        operand.dropAllUses();
        def->erase();
      }
    }
    if (!old_parallel_execute->use_empty()) {

  // directly.
  auto read_only_vars_fn = [&variable_v2s_to_replace](
                               VariableV2Op variable_v2_op) {
    if (variable_v2_op.getResult().use_empty()) {
      // Erase the op when there is no user.
      variable_v2_op.erase();
      return mlir::WalkResult::advance();
    }
    if (!all_of(variable_v2_op.getResult().getUsers(), [&variable_v2_op](

}

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;

      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()) {

    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();