auto cast_op_input = dyn_cast_or_null<TF::CastOp>(cast_input.getDefiningOp());
  while (block_arg || cast_op_input) {
    if (block_arg) {
      // Change on device function type/shape.
      HandleFuncOp(block_arg.getOwner()->getParentOp());
      block_arg = nullptr;
      cast_op_input = nullptr;
    } else {
      auto cast_input = cast_op_input.getX();
      // Update input type.
      auto transform_result_type =

        private final Closure<T> delegate;

        private BuildOperationEmittingClosure(UserCodeApplicationContext.Application application, String registrationPoint, Closure<T> delegate) {
            super(delegate.getOwner(), delegate.getThisObject());
            this.application = application;
            this.delegate = delegate;
            this.registrationPoint = registrationPoint;
        }

        @SuppressWarnings("unused")

  while (target_blocks.find(value.getParentBlock()) == target_blocks.end()) {
    Value new_value = nullptr;
    for (OpOperand& operand : value.getUses()) {
      Operation* owner = operand.getOwner();
      if (!llvm::isa<tf_device::ReturnOp>(owner)) continue;
      Operation* parent = owner->getParentOp();  // op that owns the "return"
      if (llvm::isa<tf_device::LaunchOp>(parent)) {

    if (auto read_op = llvm::dyn_cast<TF::ReadVariableOp>(&op)) {
      if (auto func_arg =
              mlir::dyn_cast<BlockArgument>(read_op.getResource())) {
        if (func_arg.getOwner() != &block)
          return read_op.emitOpError(kResourceFunctionMsg);

        ResourceInfo& resource_info = resources[func_arg.getArgNumber()];
        resource_info.read = true;

      this.task = task;
    }

    @Override
    public void run() {}

    private void setOwner(Thread thread) {
      super.setExclusiveOwnerThread(thread);
    }

    @VisibleForTesting
    @CheckForNull
    Thread getOwner() {
      return super.getExclusiveOwnerThread();
    }

    @Override
    public String toString() {
      return task.toString();

            final FileOwnerAttributeView ownerAttrView = Files.getFileAttributeView(file.toPath(), FileOwnerAttributeView.class);
            if (ownerAttrView != null) {
                final UserPrincipal owner = ownerAttrView.getOwner();
                if (owner != null) {
                    responseData.addMetaData(FS_FILE_USER, owner.getName());
                }
            }

            final Iterable<File> files = getIdeaModuleLibraryDependenciesAsFiles(ideaModule);
            ProjectLibrary library = ((ProjectInternal) scalaProject).getOwner().fromMutableState(p -> createScalaSdkLibrary(scalaProject, files, useScalaSdk, ideaModule));
            if (library != null) {

  // trait.
  static bool IsWeightQuantizableFunction(OpOperand& operand, int64_t rank) {
    if (operand.getOperandNumber() != 1) {
      return false;
    }
    Operation* user = operand.getOwner();
    if (!IsWeightOnlyQuantizableOp(*user)) {
      return false;
    }
    Method method = GetQuantizationMethodOrDefault(user);
    return HasValidWeightOnlyPtqMethod(method.weight_only_ptq(), rank);
  }

      llvm::SmallVector<mlir::Value> next_values_to_visit;
      for (auto cur_op : uses_at_current_level) {
        for (auto& cur_op_use : cur_op.getUses()) {
          Operation* next_op = cur_op_use.getOwner();
          int next_op_operand_num = cur_op_use.getOperandNumber();
          if (auto call_op = llvm::dyn_cast<mlir::CallOpInterface>(next_op)) {
            mlir::func::FuncOp func =

        // particular use that owns DumpTensor.
        rewriter.replaceUsesWithIf(
            op.getResult(0), new_op->getResult(0), [](OpOperand &use) -> bool {
              return !isa<TF::DumpTensorOp>(use.getOwner());
            });
      }
    }
  }

  DebuggerType debugger_type_;
  std::string log_dir_path_;
};

static PassRegistration<AddDumpTensorOpPass> pass;