Automatically register comparison operators in QMetaType

This removes the fully manual registration of comparison operators in
QMetaType and replaces it with an automatic registration through
Q_DECLARE_METATYPE().

[ChangeLog][QMetaType] The QMetaType::registerComparator() and
QMetaType::registerEqualsComparator() have been removed.
Q_DECLARE_METATYPE() now automatically registers any
operator==() and/or operator<() for a type visible where
it is used on that type, as part of declaring its meta-type.

Change-Id: I3df451b652b735c093533838bf32f3cc785439f8
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>

2 files changed, 59 insertions, 59 deletions

diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index 22d481f5e3..35d3f433ec 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -411,6 +411,8 @@ void tst_QMetaType::registerGadget(const char *name, const QList<GadgetPropertyT
         [](const TypeInfo *self, void *where, const void *copy) { GadgetTypedConstructor(self->typeId, where, copy); },
         [](const TypeInfo *self, void *where, void *copy) { GadgetTypedConstructor(self->typeId, where, copy); },
         [](const TypeInfo *self, void *ptr) { GadgetTypedDestructor(self->typeId, ptr); },
+        nullptr,
+        nullptr,
         nullptr };
     QMetaType gadgetMetaType(typeInfo);
     dynamicGadgetProperties->m_metatype = gadgetMetaType;
@@ -1277,7 +1279,7 @@ void tst_QMetaType::typedConstruct()
         [](const TypeInfo *self, void *where, const void *copy) { GadgetTypedConstructor(self->typeId, where, copy); },
         [](const TypeInfo *self, void *where, void *copy) { GadgetTypedConstructor(self->typeId, where, copy); },
         [](const TypeInfo *self, void *ptr) { GadgetTypedDestructor(self->typeId, ptr); },
-        nullptr };
+        nullptr, nullptr, nullptr };
     QMetaType metatype(typeInfo);
     dynamicGadgetProperties->m_metatype = metatype;
     int podTypeId = metatype.id();
@@ -2252,6 +2254,9 @@ bool operator==(const CustomEqualsOnlyType &lhs, const CustomEqualsOnlyType &rhs
 bool operator!=(const CustomEqualsOnlyType &lhs, const CustomEqualsOnlyType &rhs)
 { return !operator==(lhs, rhs); }
 
+static_assert(QTypeTraits::has_operator_equal_v<CustomEqualsOnlyType>);
+static_assert(!QTypeTraits::has_operator_less_than_v<CustomEqualsOnlyType>);
+
 Q_DECLARE_METATYPE(CustomConvertibleType);
 Q_DECLARE_METATYPE(CustomConvertibleType2);
 Q_DECLARE_METATYPE(CustomDebugStreamableType);
@@ -2497,9 +2502,7 @@ void tst_QMetaType::convertCustomType()
 
 void tst_QMetaType::compareCustomEqualOnlyType()
 {
-    int metaTypeId = qRegisterMetaType<CustomEqualsOnlyType>();
-    QMetaType::registerEqualsComparator<CustomEqualsOnlyType>();
-    int result;
+    QMetaType type = QMetaType::fromType<CustomEqualsOnlyType>();
 
     CustomEqualsOnlyType val50(50);
     CustomEqualsOnlyType val100(100);
@@ -2517,52 +2520,26 @@ void tst_QMetaType::compareCustomEqualOnlyType()
     QCOMPARE(variant100, variant100);
 
     // check QMetaType::compare works/doesn't crash for equals only comparators
-    bool wasSuccess = QMetaType::compare(variant50.constData(), variant50.constData(),
-                                          metaTypeId, &result);
-    QCOMPARE(result, 0);
-    QVERIFY(wasSuccess);
-    wasSuccess = QMetaType::compare(variant100.constData(), variant100x.constData(),
-                                          metaTypeId, &result);
-    QCOMPARE(result, 0);
-    QVERIFY(wasSuccess);
-
-    wasSuccess = QMetaType::compare(variant50.constData(), variant100.constData(),
-                                          metaTypeId, &result);
-    QVERIFY(!wasSuccess);
-
-    // check QMetaType::equals works for equals only comparator
-    wasSuccess = QMetaType::equals(variant50.constData(), variant50.constData(),
-                                   metaTypeId, &result);
-    QCOMPARE(result, 0);
-    QVERIFY(wasSuccess);
-    wasSuccess = QMetaType::equals(variant100.constData(), variant100.constData(),
-                                   metaTypeId, &result);
-    QCOMPARE(result, 0);
-    QVERIFY(wasSuccess);
-    wasSuccess = QMetaType::equals(variant100x.constData(), variant100x.constData(),
-                                   metaTypeId, &result);
-    QCOMPARE(result, 0);
-    QVERIFY(wasSuccess);
-    wasSuccess = QMetaType::equals(variant100.constData(), variant100x.constData(),
-                                   metaTypeId, &result);
-    QCOMPARE(result, 0);
-    QVERIFY(wasSuccess);
-    wasSuccess = QMetaType::equals(variant50.constData(), variant100.constData(),
-                                   metaTypeId, &result);
-    QCOMPARE(result, -1);
-    QVERIFY(wasSuccess);
-    wasSuccess = QMetaType::equals(variant50.constData(), variant100x.constData(),
-                                   metaTypeId, &result);
-    QCOMPARE(result, -1);
-    QVERIFY(wasSuccess);
+    auto cmp = type.compare(variant50.constData(), variant50.constData());
+    QVERIFY(!cmp);
+    bool equals = type.equals(variant50.constData(), variant50.constData());
+    QVERIFY(equals);
+
+    cmp = type.compare(variant100.constData(), variant100x.constData());
+    QVERIFY(!cmp);
+    equals = type.equals(variant100.constData(), variant100x.constData());
+    QVERIFY(equals);
+
+    cmp = type.compare(variant50.constData(), variant100.constData());
+    QVERIFY(!cmp);
+    equals = type.equals(variant50.constData(), variant100.constData());
+    QVERIFY(!equals);
 
     //check QMetaType::equals for type w/o equals comparator being registered
     CustomMovable movable1;
     CustomMovable movable2;
-    wasSuccess = QMetaType::equals(&movable1, &movable2,
-                                   qRegisterMetaType<CustomMovable>(), &result);
-    QVERIFY(!wasSuccess);
-
+    type = QMetaType::fromType<CustomMovable>();
+    equals = type.equals(&movable1, &movable2);
 }
 
 struct MessageHandlerCustom : public MessageHandler
diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
index 192a75d7ae..9920c8812d 100644
--- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
+++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
@@ -1826,6 +1826,12 @@ struct MyType
     {
         ++instanceCount;
     }
+    MyType &operator=(const MyType &other)
+    {
+        number = other.number;
+        text = other.text;
+        return *this;
+    }
     ~MyType()
     {
         --instanceCount;
@@ -1833,6 +1839,8 @@ struct MyType
     int number;
     const char *text;
 };
+bool operator==(const MyType &a, const MyType &b) { return a.number == b.number && a.text == b.text; }
+static_assert(QTypeTraits::has_operator_equal_v<MyType>);
 
 Q_DECLARE_METATYPE(MyType)
 Q_DECLARE_METATYPE(MyType*)
@@ -2837,28 +2845,43 @@ void tst_QVariant::invalidDate() const
 
 struct WontCompare
 {
-    int x,y,z,q,w,e,r,t;
+    int x;
 };
 Q_DECLARE_METATYPE(WontCompare);
 
+struct WillCompare
+{
+    int x;
+};
+bool operator==(const WillCompare &a, const WillCompare &b) { return a.x == b.x; }
+Q_DECLARE_METATYPE(WillCompare);
+
 void tst_QVariant::compareCustomTypes() const
 {
-    qRegisterMetaType<WontCompare>("WontCompare");
+    {
+        WontCompare f1{0};
+        const QVariant variant1(QVariant::fromValue(f1));
+
+        WontCompare f2{1};
+        const QVariant variant2(QVariant::fromValue(f2));
 
-    WontCompare f1 = {};
-    f1.x = 0;
-    const QVariant variant1(QVariant::fromValue(f1));
+        /* No comparison operator exists. */
+        QVERIFY(variant1 != variant2);
+        QVERIFY(variant1 != variant1);
+        QVERIFY(variant2 != variant2);
+    }
+    {
+        WillCompare f1{0};
+        const QVariant variant1(QVariant::fromValue(f1));
 
-    WontCompare f2 = {};
-    f2.x = 1;
-    const QVariant variant2(QVariant::fromValue(f2));
+        WillCompare f2 {1};
+        const QVariant variant2(QVariant::fromValue(f2));
 
-    /* We compare via memcmp. */
-    QVERIFY(variant1 != variant2);
-    QCOMPARE(variant1, variant1);
-    QCOMPARE(variant2, variant2);
+        QVERIFY(variant1 != variant2);
+        QCOMPARE(variant1, variant1);
+        QCOMPARE(variant2, variant2);
+    }
 }
-
 void tst_QVariant::timeToDateTime() const
 {
     const QVariant val(QTime::currentTime());