Оператор трехстороннего сравнения с противоречивым выводом порядка

Точно так же вы разрешаете любую другую функцию, которая возвращает auto, в которой разные операторы return выводят по-разному. Вы либо:

1. Убедитесь, что все return имеют один и тот же тип, или
2. Явно выберите тип возвращаемого значения.

В этом случае ints сравнивается как strong_ordering, а doubles сравнивается как partial_ordering, а strong_ordering неявно преобразуется в partial_ordering, вы можете сделать следующее:

std::partial_ordering operator <=>(const QVariant& l, const QVariant& r) {
    // rest as before
}

Или явно привести целочисленное сравнение:

      case QMetaType::Int:
         return std::partial_ordering(l.toInt() <=> r.toInt());

Это дает вам функцию, возвращающую partial_ordering.

Если вы хотите вместо этого вернуть strong_ordering, вы должны поднять double сравнение до более высокой категории. Вы можете сделать это двумя способами:

Вы можете использовать std::strong_order, что является более дорогостоящей операцией, но обеспечивает полное упорядочение всех значений с плавающей запятой. Тогда вы бы написали:

      case QMetaType::Double:
         return std::strong_order(l.toDouble(), r.toDouble());

Или вы можете сделать что-то вроде рассмотрения NaN неправильно сформированных и как-то выбросить их:

      case QMetaType::Double: {
         auto c = l.toDouble() <=> r.toDouble();
         if (c == std::partial_ordering::unordered) {
             throw something;
         } else if (c == std::partial_ordering::less) {
            return std::strong_ordering::less;
         } else if (c == std::partial_ordering::equivalent) {
            return std::strong_ordering::equal;
         } else {
            return std::strong_ordering::greater;
         }
      }

Это более утомительно, но я не уверен, что есть более прямой способ сделать такой подъем.

Типы operator<=> для int и double различаются, но они должны иметь общий тип. Возможно, вы захотите использовать компилятор для автоматического поиска нужного типа. Вы могли бы использовать std::common_type, но это было бы довольно уродливо. Проще просто использовать то, что std::common_type type делает в (при реализации в библиотеке, а не в компиляторе), и использовать тернарный оператор:

auto operator <=> (const QVariant& l, const QVariant& r)
{   
    return l.type() == QMetaType:Int? l.toInt() <=> r.toInt()
         : l.type() == QMetaType::Double? l.toDouble() <=> r.toDouble()
         : throw;
}

Я поэкспериментировал с кодом шаблона, чтобы реализовать идею Дитмара Кюля об использовании std::common_type. Это код примера результата:

template <typename CommonT, typename... ArgsT> requires (sizeof...(ArgsT) == 0)
inline CommonT variantSpaceshipHelper([[maybe_unused]] const QVariant& pLeft, [[maybe_unused]] const QVariant& pRight) noexcept
{
   std::terminate(); // Variant type does not match any of the given template types
}

template <typename CommonT, typename T, typename... ArgsT>
inline CommonT variantSpaceshipHelper(const QVariant& pLeft, const QVariant& pRight) noexcept
{
   if (pLeft.type() == static_cast<QVariant::Type>(qMetaTypeId<T>()))
   {
      return (pLeft.value<T>() <=> pRight.value<T>());
   }

   return variantSpaceshipHelper<CommonT, ArgsT...>(pLeft, pRight);
}

template <typename... ArgsT>
inline auto variantSpaceship(const QVariant& pLeft, const QVariant& pRight) noexcept
{
   using CommonT = std::common_type_t<decltype(std::declval<ArgsT>() <=> std::declval<ArgsT>())...>;
   return variantSpaceshipHelper<CommonT, ArgsT...>(pLeft, pRight);
}

inline auto operator <=>(const QVariant& pLeft, const QVariant& pRight) noexcept
{
   assert(pLeft.type() == pRight.type());
   return variantSpaceship<int, double>(pLeft, pRight);
}

К вызову variantSpaceship можно легко добавить дополнительные типы.