QUuid, GUID: use new comparison helper macros

Replace public friend operators operator==(), operator!=(),
operator<(), etc of QUuid and GUID with friend methods
comparesEqual() / compareThreeWay().

Use Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE, because
the (in)equality operators are constexpr.
And then we use helper macros, because the other relational
operators are not constexpr. Cannot make relational operators
constexpr, because it requires to make variant() and isNull() methods
constexpr and QT_CORE_INLINE_SINCE. But the experiments
show that it does not work with adding constexpr to
QT_CORE_INLINE_SINCE.

Put relational operators under !QT_CORE_REMOVED_SINCE(6, 8) to prevent
an ambiguity. On Windows the metatype for QUuid is created
in removed_api.cpp. That leads to an ambiguity, and as a result
the compiler fails to create the equals methods of QMetaTypeInterface.
This, in turn, leads to the failed comparisons.
The usage of !QT_CORE_REMOVED_SINCE(6, 8) solves the problem.

Task-number: QTBUG-120304
Change-Id: I640bdeb8f1f7306ba06b9e4193d008cf2bb6dbfb
Reviewed-by: Ivan Solovev <[email protected]>

2 files changed, 79 insertions, 55 deletions

diff --git a/src/corelib/plugin/quuid.cpp b/src/corelib/plugin/quuid.cpp
index 9c7216c3c5b..42f21eea88c 100644
--- a/src/corelib/plugin/quuid.cpp
+++ b/src/corelib/plugin/quuid.cpp
@@ -142,6 +142,11 @@ static QUuid createFromName(const QUuid &ns, const QByteArray &baseData, QCrypto
 
     \reentrant
 
+    \compares strong
+    \compareswith strong GUID
+    \note Comparison with GUID is Windows-only.
+    \endcompareswith
+
     Using \e{U}niversally \e{U}nique \e{ID}entifiers (UUID) is a
     standard way to uniquely identify entities in a distributed
     computing environment. A UUID is a 16-byte (128-bit) number
@@ -600,16 +605,16 @@ QUuid QUuid::fromRfc4122(QByteArrayView bytes) noexcept
 }
 
 /*!
-    \fn bool QUuid::operator==(const QUuid &other) const
+    \fn bool QUuid::operator==(const QUuid &lhs, const QUuid &rhs)
 
-    Returns \c true if this QUuid and the \a other QUuid are identical;
+    Returns \c true if \a lhs QUuid and the \a rhs QUuid are identical;
     otherwise returns \c false.
 */
 
 /*!
-    \fn bool QUuid::operator!=(const QUuid &other) const
+    \fn bool QUuid::operator!=(const QUuid &lhs, const QUuid &rhs)
 
-    Returns \c true if this QUuid and the \a other QUuid are different;
+    Returns \c true if \a lhs QUuid and the \a rhs QUuid are different;
     otherwise returns \c false.
 */
 
@@ -898,51 +903,31 @@ QUuid::Version QUuid::version() const noexcept
 }
 
 /*!
-    \fn bool QUuid::operator<(const QUuid &other) const
+    \fn bool QUuid::operator<(const QUuid &lhs, const QUuid &rhs)
 
-    Returns \c true if this QUuid has the same \l{Variant field}
-    {variant field} as the \a other QUuid and is lexicographically
-    \e{before} the \a other QUuid. If the \a other QUuid has a
+    Returns \c true if \a lhs QUuid has the same \l{Variant field}
+    {variant field} as the \a rhs QUuid and is lexicographically
+    \e{before} the \a rhs QUuid. If the \a rhs QUuid has a
     different variant field, the return value is determined by
     comparing the two \l{QUuid::Variant} {variants}.
 
     \sa variant()
 */
-bool QUuid::operator<(const QUuid &other) const noexcept
-{
-    if (variant() != other.variant())
-        return variant() < other.variant();
-
-#define ISLESS(f1, f2) if (f1!=f2) return (f1<f2);
-    ISLESS(data1, other.data1);
-    ISLESS(data2, other.data2);
-    ISLESS(data3, other.data3);
-    for (int n = 0; n < 8; n++) {
-        ISLESS(data4[n], other.data4[n]);
-    }
-#undef ISLESS
-    return false;
-}
 
 /*!
-    \fn bool QUuid::operator>(const QUuid &other) const
+    \fn bool QUuid::operator>(const QUuid &lhs, const QUuid &rhs)
 
-    Returns \c true if this QUuid has the same \l{Variant field}
-    {variant field} as the \a other QUuid and is lexicographically
-    \e{after} the \a other QUuid. If the \a other QUuid has a
+    Returns \c true if \a lhs QUuid has the same \l{Variant field}
+    {variant field} as the \a rhs QUuid and is lexicographically
+    \e{after} the \a rhs QUuid. If the \a rhs QUuid has a
     different variant field, the return value is determined by
     comparing the two \l{QUuid::Variant} {variants}.
 
     \sa variant()
 */
-bool QUuid::operator>(const QUuid &other) const noexcept
-{
-    return other < *this;
-}
 
 /*!
-    \fn bool operator<=(const QUuid &lhs, const QUuid &rhs)
-    \relates QUuid
+    \fn bool QUuid::operator<=(const QUuid &lhs, const QUuid &rhs)
     \since 5.5
 
     Returns \c true if \a lhs has the same \l{Variant field}
@@ -955,8 +940,7 @@ bool QUuid::operator>(const QUuid &other) const noexcept
 */
 
 /*!
-    \fn bool operator>=(const QUuid &lhs, const QUuid &rhs)
-    \relates QUuid
+    \fn bool QUuid::operator>=(const QUuid &lhs, const QUuid &rhs)
     \since 5.5
 
     Returns \c true if \a lhs has the same \l{Variant field}
@@ -1009,17 +993,17 @@ QUuid QUuid::createUuid()
 #endif // !Q_OS_WIN && !QT_BOOTSTRAPPED
 
 /*!
-    \fn bool QUuid::operator==(const GUID &guid) const
+    \fn bool QUuid::operator==(const QUuid &lhs, const GUID &rhs)
 
-    Returns \c true if this UUID is equal to the Windows GUID \a guid;
+    Returns \c true if \a lhs UUID is equal to the Windows GUID \a rhs;
     otherwise returns \c false.
 */
 
 /*!
-    \fn bool QUuid::operator!=(const GUID &guid) const
+    \fn bool QUuid::operator!=(const QUuid &lhs, const GUID &rhs)
 
-    Returns \c true if this UUID is not equal to the Windows GUID \a
-    guid; otherwise returns \c false.
+    Returns \c true if \a lhs UUID is not equal to the Windows GUID \a rhs;
+    otherwise returns \c false.
 */
 
 #ifndef QT_NO_DEBUG_STREAM
diff --git a/src/corelib/plugin/quuid.h b/src/corelib/plugin/quuid.h
index 7125e8e2cc7..504a6971bde 100644
--- a/src/corelib/plugin/quuid.h
+++ b/src/corelib/plugin/quuid.h
@@ -4,6 +4,7 @@
 #ifndef QUUID_H
 #define QUUID_H
 
+#include <QtCore/qcompare.h>
 #include <QtCore/qendian.h>
 #include <QtCore/qstring.h>
 
@@ -122,27 +123,59 @@ QT_WARNING_POP
     constexpr quint128 toUInt128(QSysInfo::Endian order = QSysInfo::BigEndian) const noexcept;
 #endif
 
-    constexpr bool operator==(const QUuid &orig) const noexcept
+private:
+    friend constexpr bool comparesEqual(const QUuid &lhs, const QUuid &rhs) noexcept
     {
-        if (data1 != orig.data1 || data2 != orig.data2 ||
-             data3 != orig.data3)
+        if (lhs.data1 != rhs.data1 || lhs.data2 != rhs.data2 || lhs.data3 != rhs.data3)
             return false;
 
-        for (uint i = 0; i < 8; i++)
-            if (data4[i] != orig.data4[i])
+        for (uint i = 0; i < 8; i++) {
+            if (lhs.data4[i] != rhs.data4[i])
                 return false;
+        }
 
         return true;
     }
+    friend Qt::strong_ordering compareThreeWay(const QUuid &lhs, const QUuid &rhs) noexcept
+    {
+        if (lhs.variant() != rhs.variant())
+            return Qt::compareThreeWay(lhs.variant(), rhs.variant());
+
+#define CHECK(f1, f2) if ((f1) != (f2)) return Qt::compareThreeWay(f1, f2)
+        CHECK(lhs.data1, rhs.data1);
+        CHECK(lhs.data2, rhs.data2);
+        CHECK(lhs.data3, rhs.data3);
+#undef CHECK
+        int c = std::memcmp(lhs.data4, rhs.data4, sizeof(lhs.data4));
+        return Qt::compareThreeWay(c, 0);
+    }
+
+public:
+/*  To prevent a meta-type creation ambiguity on Windows, we put comparison
+    macros under NOT QT_CORE_REMOVED_SINCE(6, 8) part. */
+#if QT_CORE_REMOVED_SINCE(6, 8)
+    constexpr bool operator==(const QUuid &orig) const noexcept
+    {
+        return comparesEqual(*this, orig);
+    }
 
     constexpr bool operator!=(const QUuid &orig) const noexcept
     {
-        return !(*this == orig);
+        return !operator==(orig);
     }
 
     bool operator<(const QUuid &other) const noexcept;
     bool operator>(const QUuid &other) const noexcept;
-
+#else
+private:
+#if defined(__cpp_lib_three_way_comparison) && !defined(Q_QDOC)
+    QT_DECLARE_3WAY_HELPER_STRONG(QUuid, QUuid, /* non-constexpr */, /* no attributes */)
+#else
+    QT_DECLARE_ORDERING_HELPER_STRONG(QUuid, QUuid, /* non-constexpr */, /* no attributes */)
+#endif // defined(__cpp_lib_three_way_comparison) && !defined(Q_QDOC)
+    Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QUuid)
+#endif // QT_CORE_REMOVED_SINCE(6, 8)
+public:
 #if defined(Q_OS_WIN) || defined(Q_QDOC)
     // On Windows we have a type GUID that is used by the platform API, so we
     // provide convenience operators to cast from and to this type.
@@ -162,17 +195,29 @@ QT_WARNING_POP
         GUID guid = { data1, data2, data3, { data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7] } };
         return guid;
     }
-
+private:
+    friend constexpr bool comparesEqual(const QUuid &lhs, const GUID &rhs) noexcept
+    {
+        return comparesEqual(lhs, QUuid(rhs));
+    }
+public:
+/*  To prevent a meta-type creation ambiguity on Windows, we put comparison
+    macros under NOT QT_CORE_REMOVED_SINCE(6, 8) part. */
+#if QT_CORE_REMOVED_SINCE(6, 8)
     constexpr bool operator==(const GUID &guid) const noexcept
     {
-        return *this == QUuid(guid);
+        return comparesEqual(*this, QUuid(guid));
     }
 
     constexpr bool operator!=(const GUID &guid) const noexcept
     {
-        return !(*this == guid);
+        return !operator==(guid);
     }
+#else
+    Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QUuid, GUID)
+#endif // !QT_CORE_REMOVED_SINCE(6, 8)
 #endif
+public:
     static QUuid createUuid();
 #ifndef QT_BOOTSTRAPPED
     static QUuid createUuidV3(const QUuid &ns, const QByteArray &baseData);
@@ -291,11 +336,6 @@ constexpr quint128 QUuid::toUInt128(QSysInfo::Endian order) const noexcept
 }
 #endif
 
-inline bool operator<=(const QUuid &lhs, const QUuid &rhs) noexcept
-{ return !(rhs < lhs); }
-inline bool operator>=(const QUuid &lhs, const QUuid &rhs) noexcept
-{ return !(lhs < rhs); }
-
 #if defined(Q_QDOC)
 // provide fake declarations of qXXXEndian() functions, so that qDoc could
 // distinguish them from the general template