return nullptr;
}

// Returns the `shared_name` attribute value if exists. If not, returns an
// empty string.
StringRef GetSharedName(Operation* op) {
  if (!op->hasAttrOfType<StringAttr>(kSharedNameAttr)) return "";
  return op->getAttrOfType<StringAttr>(kSharedNameAttr).getValue();
}

// Gets the GraphOp from the function op. Returns an empty op iff it doesn't
// exist.

    if (!is_generator(alias)) return true;

    StringAttr device;
    if (auto arg = mlir::dyn_cast<BlockArgument>(alias)) {
      device = func.getArgAttrOfType<mlir::StringAttr>(arg.getArgNumber(),
                                                       kFuncDeviceAttr);
    } else {
      device = alias.getDefiningOp()->getAttrOfType<StringAttr>(kDeviceAttr);
    }

    if (!device) return false;

  return std::make_pair(f_attr.getValue().str(), kEmptyNodeName.str());
}

Operation *DuplicateOp(TF::PartitionedCallOp call_op, PatternRewriter &rewriter,
                       const StringAttr &new_ref_func_name) {
  // Create PartitionedCallOp to the copied composite function. This
  // PartitionedCallOp does not have kQuantTraitAttrName, and therefore won't
  // get quantized.

  if (!mlir::isa<mlir::StringAttr>(shard_attr)) return mlir::failure();

  auto shard_str = mlir::cast<mlir::StringAttr>(shard_attr).getValue().str();
  return DecodeShardingAttribute(shard_str, sharding, report_error);
}

void EncodeSharding(mlir::Operation* op, llvm::StringRef shard_str) {
  if (!op->hasAttrOfType<mlir::StringAttr>(shard_str)) return;

  ::xla::OpSharding sharding;

  auto perm = GetDataFormatPermutation(op->getDataFormat(), data_format);
  if (perm.empty()) return failure();

  // Update data format attribute.
  (*op)->setAttr("data_format", StringAttr::get(op->getContext(), data_format));

  // Update types for all layout sensitive results.
  auto layout_sensitive = cast<LayoutSensitiveInterface>(op->getOperation());

  if (dict_attr) {
    TF_RET_CHECK(mlir::isa<mlir::StringAttr>(dict_attr.get("inputs")))
        << "inputs missing in entry function attribute";
    TF_RET_CHECK(mlir::isa<mlir::StringAttr>(dict_attr.get("outputs")))
        << "outputs missing in entry function attribute";
    mlir::cast<mlir::StringAttr>(dict_attr.get("inputs"))
        .getValue()

  if (dict_attr) {
    TF_RET_CHECK(mlir::isa<mlir::StringAttr>(dict_attr.get("inputs")))
        << "inputs missing in entry function attribute";
    TF_RET_CHECK(mlir::isa<mlir::StringAttr>(dict_attr.get("outputs")))
        << "outputs missing in entry function attribute";
    mlir::cast<mlir::StringAttr>(dict_attr.get("inputs"))
        .getValue()

  auto device = op->getAttrOfType<StringAttr>(kDevice);
  if (device == nullptr || device.getValue().empty()) return std::nullopt;

  return GetCanonicalHardwareName(device.getValue().str());
}

// Get inference type attribute from the operation if available.
inline std::optional<InferenceType> GetInferenceTypeAnnotation(Operation* op) {
  auto inference_type = op->getAttrOfType<StringAttr>(kInferenceType);

        islands_to_outline.push_back(island_op);
        break;
      }
      auto device_type =
          op.getAttrOfType<StringAttr>(TF::kCompileDeviceTypeAttr);
      if (device_type && device_type.getValue() == TF::kTpuDevice &&
          !op.hasAttrOfType<StringAttr>(TF::kReplicationInfoAttr)) {
        // Handle single-core TPU case (no `TPUReplicateMetadataOp`).
        islands_to_outline.push_back(island_op);

    if (mlir::isa<TF::ResourceType>(
            getElementTypeOrSelf(iter.value().getType()))) {
      resource_vec.push_back(GetResourceHandleValueAndIdBase(
          mlir::cast<mlir::StringAttr>(getContainer()[index]).getValue(),
          mlir::cast<mlir::StringAttr>(getSharedName()[index]).getValue(),
          device, getResults()[index], resource_handle_id_map, next_id));
    }
  }
  return resource_vec;
}