.cast<TF::ResourceType>()
                                    .getSubtypes()))
      return false;

  return true;
}

Type GetResourceSubtype(Type type) {
  return type.cast<TensorType>()
      .getElementType()
      .cast<TF::ResourceType>()
      .getSubtypes()
      .front();
}

Type GetResourceSubtype(Value resource) {

mlir::LogicalResult ValidateResourceArgument(func::FuncOp function,
                                             BlockArgument resource_arg,
                                             TF::ResourceType resource_type) {
  if (resource_type.getSubtypes().size() != 1)
    return function.emitError()
           << "expects resource type of argument "
           << resource_arg.getArgNumber() << " to have one subtype, got "
           << resource_type;

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

std::optional<Type> GetSingularVariantBaseType(Value val) {
  auto val_t = mlir::getElementTypeOrSelf(val).dyn_cast_or_null<VariantType>();
  if (!val_t) {
    return std::nullopt;
  }
  llvm::ArrayRef<mlir::TensorType> subtypes = val_t.getSubtypes();
  if (subtypes.size() != 1) {
    return std::nullopt;
  }
  return subtypes[0].getElementType();
}

// Create an `ConstBytesAttr` which encodes the options

      .create<TF::ReadVariableOp>(
          loc,
          ArrayRef<Type>{mlir::cast<TF::ResourceType>(
                             getElementTypeOrSelf(local_var.getType()))
                             .getSubtypes()[0]},
          ArrayRef<Value>{local_var})
      .getValue();
}

// Creates an AssignVariableOp on a local variable.
TF::AssignVariableOp WriteLocalVariable(Value local_var, Value value,

    Type type, llvm::SmallVector<int64_t, 8>* shape) {
  auto variant_type =
      mlir::dyn_cast<TF::VariantType>(getElementTypeOrSelf(type));
  if (!variant_type || variant_type.getSubtypes().size() != 1) return failure();
  TensorType tensor_type = variant_type.getSubtypes().front();
  if (!tensor_type.hasStaticShape()) return failure();
  for (auto d : tensor_type.getShape()) shape->push_back(d);
  return success();
}

    return size.emitOpError("unknown tensor array");
  }
  auto buffer_type = getElementTypeOrSelf(local_var.getType())
                         .cast<TF::ResourceType>()
                         .getSubtypes()[0]
                         .cast<RankedTensorType>();
  OpBuilder builder(size);
  auto result = cutil::CreateScalarConst(buffer_type.getDimSize(0), builder,
                                         size.getLoc());

    // Get the data type of the resource.
    auto subtypes = mlir::cast<TF::ResourceType>(
                        getElementTypeOrSelf(execute.getOperand(it->second)))
                        .getSubtypes();
    if (subtypes.size() != 1) continue;
    auto data_type = getElementTypeOrSelf(subtypes[0]);
    // The XLA backend does not yet support formatting 64-bit data types.

  if (mlir::isa<mlir::TF::StringType>(type)) return true;

  auto sub_type = mlir::dyn_cast<mlir::TF::TensorFlowTypeWithSubtype>(type);
  if (!sub_type) return false;

  bool has_string = llvm::any_of(sub_type.GetSubtypes(), [](TensorType type) {
    return mlir::isa<mlir::TF::StringType>(type.getElementType());
  });
  return has_string;
}

bool HasStringOperand(Operation& op) {
  for (auto operand : op.getOperands()) {

  if (auto resource_type =
          mlir::dyn_cast<mlir::TF::ResourceType>(arg_type.getElementType())) {
    llvm::ArrayRef<mlir::TensorType> subtypes = resource_type.getSubtypes();
    if (!subtypes.empty()) {
      AttrValue handle_dtypes_attr;
      AttrValue handle_shapes_attr;
      for (mlir::TensorType subtype : subtypes) {
        DataType dtype;