* The converter can obtain the node identity for each node of the supported type via {@link #getNodeIdentity(Node)}.
 * <p>
 * Instances of this class are expected to be thread-safe.
 */
@NonNullApi
@ThreadSafe
public interface ToPlannedNodeConverter {

    /**
     * Type of node that this converter can identify and convert to a planned node.
     */

      tf_executor.yield
    }
    tf_executor.fetch %island : !tf_executor.control
  }
  func.return
}

// -----
// Tests handling of Cast, Identity, and IdentityN

!tf_res = tensor<*x!tf_type.resource<tensor<32xf32>>>
// CHECK-LABEL: func @aliasing_identities
func.func @aliasing_identities(%arg0: tensor<32xf32>) -> () {
  tf_executor.graph {
    // CHECK: tf_executor.island

// Test that the Identity op has been created to fetch the file prefix
// argument. It should also have control dependency to the `SaveV2` op.
// CHECK: %[[IDENTITY:.*]], %[[CTL_1:.*]] = tf_executor.island(%[[CTL_0]]) wraps "tf.Identity"(%[[ARG_0]])
// CHECK: tf_executor.fetch %[[CTL_1]] : !tf_executor.control
// CHECK: return

// -----

will be transformed into:

```mlir
func @my_fn(%arg0: tensor<i32>, %arg1: tensor<i32>) -> (tensor<i32>, tensor<i32>) {
  %identity = "tf.Identity"(%arg0) : (tensor<i32>) -> tensor<i32>
  %identity_n:2 = "tf.IdentityN"(%arg1, %identity) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)
  return %identity, %identity_n#0 : tensor<i32>, tensor<i32>
}
```
### `-tf-executor-tpu-v1-island-coarsening`

                        visited_wrapped_ops, /*incoming=*/false)) {
    return failure();
  }
  return success();
}

// Whenever we find an Identity op that is unqualified, we remove this Identity
// op from the list `tpu_ops`. An unqualified Identity op indicates either its
// inputs or its outputs do not belong to the same cluster.
bool ExcludeIdentityOp(llvm::SmallDenseSet<Operation*>& tpu_ops,

Laura Kassovic <******@****.***> 1701107622 -0800

      return std::make_tuple(t, identity_ops);
    } else if (auto identity =
                   llvm::dyn_cast_or_null<mlir::TF::IdentityOp>(user)) {
      identity_ops.emplace_back(identity);
      result = identity->getResult(0);
    } else {
      result = OpResult();  // reset to stop iterating
    }
  } while (result);

  return std::make_tuple(T(), identity_ops);
}

    "FakeQuantWithMinMaxVarsPerChannel",
    "FakeQuantWithMinMaxVarsPerChannelGradient",
    "Fill",
    "Fingerprint",
    "Gather",
    "GuaranteeConst",
    "Identity",
    "IdentityN",
    "InplaceAdd",
    "InplaceSub",
    "InplaceUpdate",
    "InvertPermutation",
    "ListDiff",
    "MatrixBandPart",
    "MatrixDiag",
    "MatrixDiagPart",
    "MatrixDiagPartV2",

// value.
Status Identity(AbstractContext* ctx, AbstractTensorHandle* const input,
                AbstractTensorHandle** output, const char* name = nullptr,
                const char* raw_device_name = nullptr);

// Returns a list of tensors with the same shapes and contents as the input
Status IdentityN(AbstractContext* ctx,
                 absl::Span<AbstractTensorHandle* const> input,

    @Override
    public Identity identify(Map<String, ValueSnapshot> identityInputs, Map<String, CurrentFileCollectionFingerprint> identityFileInputs) {
        Hasher hasher = Hashing.newHasher();
        identityInputs.values().forEach(value -> requireNonNull(value).appendToHasher(hasher));
        String identity = hasher.hash().toString();
        return () -> identity;
    }

    @Override