const bool has_variant_input = llvm::any_of(op->getOperands(), [](Value val) {
    return val.getType().cast<TensorType>().getElementType().isa<VariantType>();
  });
  const bool has_variant_output =
      llvm::any_of(op->getResultTypes(), [](Type t) {
        return t.cast<TensorType>().getElementType().isa<VariantType>();
      });
  return has_variant_input || has_variant_output;
}

    Type elementType = getElementTypeOrSelf(op->getResult(0));
    Type newType = nullptr;
    if (auto variant = dyn_cast<TF::VariantType>(elementType)) {
      ArrayRef<TensorType> sub = variant.getSubtypes();
      if (sub.size() == 1) {
        auto inner = sub[0];
        if (!isa<TF::VariantType>(inner)) {
          newType = inner;
        }
      }
    }
    if (!newType) {
      return failure();
    }

using ::mlir::tf_type::TensorFlowRefType;          // NOLINT
using ::mlir::tf_type::TensorFlowType;             // NOLINT
using ::mlir::tf_type::TensorFlowTypeWithSubtype;  // NOLINT
using ::mlir::tf_type::VariantType;                // NOLINT

#define HANDLE_TF_TYPE(tftype, enumerant, name) \
  using tftype##Type = mlir::tf_type::tftype##Type;
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_types.def"

// if `type` is a tensor of variant. Otherwise, returns `type` unmodified.
Type VariantToUnrankedTensorType(Type type, Value value) {
  TF::VariantType variant_ty =
      getElementTypeOrSelf(type).dyn_cast<TF::VariantType>();
  if (!variant_ty) {
    return type;
  }
  if (!variant_ty.getSubtypes().empty()) {
    // Short-circut if the variant type has subtype info.

  std::unique_ptr<std::vector<tensorflow::mutex_lock>> locks;
  std::unique_ptr<std::vector<tensorflow::tf_shared_lock>> shared_locks;
};

tensorflow::Status EnsureSparseVariableAccess(
    TF_OpKernelContext* ctx, bool variantType,
    void (*copyFunc)(TF_OpKernelContext* ctx, TF_Tensor* source,
                     TF_Tensor* dest),
    tensorflow::Var* var, bool lock_held = false) {

  StringRef config = recv_op ? recv_op.getConfig() : send_op.getConfig();

  // Create XlaRecvTPUEmbeddingDeduplicationData op.
  OpBuilder builder(region);
  auto output_ty =
      RankedTensorType::get({}, VariantType::get(region->getContext()));
  auto dedup_op = builder.create<XlaRecvTPUEmbeddingDeduplicationDataOp>(
      loc, output_ty, config);

  // Rewrite RecvTPUEmbeddingActivations op to the corresponding internal op.

      return builder.getIntegerType(64, /*isSigned=*/false);
    case tflite::TensorType_RESOURCE:
      return mlir::TF::ResourceType::get(builder.getContext());
    case tflite::TensorType_VARIANT:
      return mlir::TF::VariantType::get(builder.getContext());
  }
}

tensorflow::DataType TflTypeToTfType(tflite::TensorType type) {
  switch (type) {
    case tflite::TensorType_BOOL:
      return tensorflow::DT_BOOL;

  // require "raising" later.
  for (const Type type : inst->getResultTypes()) {
    if (const TensorType tensor_type = mlir::dyn_cast<TensorType>(type)) {
      if (mlir::isa<VariantType>(tensor_type.getElementType())) {
        return false;
      }
    }
  }

  // Operations that execute function calls shouldn't be constant folded.

      while_input_types, SmallVector<Location>(while_input_types.size(), loc));
  auto get_next = builder.create<IteratorGetNextAsOptionalOp>(
      loc, RankedTensorType::get({}, builder.getType<VariantType>()),
      anonymous_iterator.getResult(), anonymous_iterator.getOutputTypes(),
      anonymous_iterator.getOutputShapes());
  auto optional_has_value = builder.create<OptionalHasValueOp>(

            tensorflow::GetTypeFromTFTensorShape(shape, nested_elem_type));
      } else {
        tensor_types.push_back(UnrankedTensorType::get(nested_elem_type));
      }
    }
    elem_type = mlir::TF::VariantType::get(tensor_types, builder.getContext());
  }
  if (IsQuantized(tensor) && !get_storage) {
    TF_ASSIGN_OR_RETURN(elem_type,
                        GetQuantizedType(tensor, builder, is_constant));