}
  }
  return result;
}

void EraseReturnOperands(Region* region, llvm::BitVector& erase) {
  for (Block& block : region->getBlocks()) {
    for (Operation& op : block.getOperations()) {
      if (!op.hasTrait<OpTrait::ReturnLike>()) continue;
      op.eraseOperands(erase);
    }
  }
}

// Erases the given results from an operation, similar to what
// Operation::eraseArguments does (but for results).

  dead_ops.insert(vars.begin(), vars.end());

  // Removes relevant ops in topological order.
  for (auto& op : vars) RecursiveRemove(op, erase_list, dead_ops);

  // Erases the ops.
  for (auto op : erase_list) op->erase();
}

void RemoveVariablesInSessionInitializerPass::runOnOperation() {
  ModuleOp module_op = getOperation();

  for (auto init_func_op : GetInitializerFunctions(module_op)) {

  }

  // Erase unreachable ops in reverse order so references don't need to be
  // dropped before removing an op. Going in reverse order will guarantee that
  // when an op to be erased is reached, there are no users left.
  for (Operation& op :
       llvm::make_early_inc_range(llvm::reverse(graph.GetBody())))
    if (!reachable_ops.contains(&op)) op.erase();
}

}  // namespace

  // argument is not erased.

  "tf_saved_model.global_tensor"() { sym_name = "exported_unbound", tf_saved_model.exported_names = ["exported_unbound"], type = tensor<f32>, value = dense<42.> : tensor<f32> } : () -> ()
  // CHECK: sym_name = "exported_unbound"

  // Test case: Check that a global tensor that isn't even bound to an argument
  // is erased.

import java.lang.invoke.MethodType;
import java.lang.reflect.Method;
import java.util.Objects;

/**
 * A representation of a method signature. Contains the method name, erased parameter types and erased return type.
 */
public final class MethodSignature {
    public static MethodSignature from(Method method) {
        return new MethodSignature(method.getName(), MethodType.methodType(

      dq.getOutput().replaceAllUsesWith(dcast);
      dq.erase();
    } else if (auto q = llvm::dyn_cast<QuantizeOp>(op)) {
      auto qcast = b.create<quantfork::QuantizeCastOp>(
          q.getLoc(), q.getOutput().getType(), q.getInput());
      q.getOutput().replaceAllUsesWith(qcast);
      q.erase();
    } else if (auto q = llvm::dyn_cast<ConstOp>(op)) {
      auto value = q.getValue();

            1 * ansi.eraseLine(Ansi.Erase.ALL)
            1 * ansi.cursorDown(1)
            1 * ansi.eraseLine(Ansi.Erase.ALL)
            1 * ansi.cursorDown(1)
            1 * ansi.eraseLine(Ansi.Erase.ALL)

            // Parking
            1 * ansi.cursorDown(1)
            1 * ansi.eraseLine(Ansi.Erase.ALL)

            1 * ansi.cursorUp(absoluteDeltaRowToAreaTop)

    if (candidate_result == body_yield_operand) continue;
    if (!candidate_result.use_empty()) return false;
  }

  // Now we know that it is safe to erase the candidate op along with `result`
  // and the corresponding operand. Here we only erase the op and replace its
  // result usage with the corresponding block argument, the result and operand
  // will be removed later in a canonicalization pattern.

      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
    auto it = cache_.find(key);
    if (it == cache_.end()) {
      return false;
    }
    lru_list_.erase(it->second.lru_iterator);
    if (timer_seconds_() - it->second.timestamp > max_age_) {
      cache_.erase(it);
      return false;
    }
    *value = it->second.value;
    lru_list_.push_front(it->first);
    it->second.lru_iterator = lru_list_.begin();

  TF_CHECK_OK(ReadFileToString(env, source_file_name, &expected_source));

  // Remove carriage returns (for Windows)
  expected_header.erase(
      std::remove(expected_header.begin(), expected_header.end(), '\r'),
      expected_header.end());
  expected_source.erase(
      std::remove(expected_source.begin(), expected_source.end(), '\r'),
      expected_source.end());

  EXPECT_EQ(expected_header, generated_header);