Replace most use of QVariant::type and occurrences of QVariant::Type

I made a clazy automated check that replaced the use of QVariant::Type
by the equivalent in QMetaType.
This has been deprecated since Qt 5.0, but many uses were not yet removed.

In addition, there was some manual changes to fix the compilation errors.

Adapted the Private API of QDateTimeParser and QMimeDataPrivate
and adjust QDateTimeEdit and QSpinBox.

QVariant(QVariant::Invalid) in qstylesheet made no sense.

But note that in QVariant::save, we actually wanted to use the non-user type.

In the SQL module, many changes were actually reverted because the API
still expects QVarient::Type.

Change-Id: I98c368490e4ee465ed3a3b63bda8b8eaa50ea67e
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

10 files changed, 56 insertions, 56 deletions

diff --git a/src/dbus/qdbusabstractinterface.cpp b/src/dbus/qdbusabstractinterface.cpp
index 8a11767140..d603264a1e 100644
--- a/src/dbus/qdbusabstractinterface.cpp
+++ b/src/dbus/qdbusabstractinterface.cpp
@@ -157,7 +157,7 @@ bool QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp, void *retu
     const int type = mp.userType();
     // is this metatype registered?
     const char *expectedSignature = "";
-    if (int(mp.type()) != QMetaType::QVariant) {
+    if (int(mp.userType()) != QMetaType::QVariant) {
         expectedSignature = QDBusMetaType::typeToSignature(type);
         if (expectedSignature == nullptr) {
             qWarning("QDBusAbstractInterface: type %s must be registered with Qt D-Bus before it can be "
diff --git a/src/dbus/qdbusargument.h b/src/dbus/qdbusargument.h
index 477bd1e8fd..339f8c5dc8 100644
--- a/src/dbus/qdbusargument.h
+++ b/src/dbus/qdbusargument.h
@@ -330,7 +330,7 @@ inline const QDBusArgument &operator>>(const QDBusArgument &arg, QMap<Key, T> &m
 
 inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantMap &map)
 {
-    arg.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>());
+    arg.beginMap(QMetaType::QString, qMetaTypeId<QDBusVariant>());
     QVariantMap::ConstIterator it = map.constBegin();
     QVariantMap::ConstIterator end = map.constEnd();
     for ( ; it != end; ++it) {
@@ -379,7 +379,7 @@ inline const QDBusArgument &operator>>(const QDBusArgument &arg, QHash<Key, T> &
 
 inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantHash &map)
 {
-    arg.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>());
+    arg.beginMap(QMetaType::QString, qMetaTypeId<QDBusVariant>());
     QVariantHash::ConstIterator it = map.constBegin();
     QVariantHash::ConstIterator end = map.constEnd();
     for ( ; it != end; ++it) {
diff --git a/src/dbus/qdbusintegrator.cpp b/src/dbus/qdbusintegrator.cpp
index bca02be59e..669b330f1d 100644
--- a/src/dbus/qdbusintegrator.cpp
+++ b/src/dbus/qdbusintegrator.cpp
@@ -1822,7 +1822,7 @@ void QDBusConnectionPrivate::setConnection(DBusConnection *dbc, const QDBusError
     hook.service = QDBusUtil::dbusService();
     hook.path.clear(); // no matching
     hook.obj = this;
-    hook.params << QMetaType::Void << QVariant::String; // both functions take a QString as parameter and return void
+    hook.params << QMetaType::Void << QMetaType::QString; // both functions take a QString as parameter and return void
 
     hook.midx = staticMetaObject.indexOfSlot("registerServiceNoLock(QString)");
     Q_ASSERT(hook.midx != -1);
@@ -1836,7 +1836,7 @@ void QDBusConnectionPrivate::setConnection(DBusConnection *dbc, const QDBusError
     // we don't use connectSignal here because the rules are added by connectSignal on a per-need basis
     hook.params.clear();
     hook.params.reserve(4);
-    hook.params << QMetaType::Void << QVariant::String << QVariant::String << QVariant::String;
+    hook.params << QMetaType::Void << QMetaType::QString << QMetaType::QString << QMetaType::QString;
     hook.midx = staticMetaObject.indexOfSlot("serviceOwnerChangedNoLock(QString,QString,QString)");
     Q_ASSERT(hook.midx != -1);
     signalHooks.insert(QLatin1String("NameOwnerChanged:" DBUS_INTERFACE_DBUS), hook);
diff --git a/src/dbus/qdbusinterface.cpp b/src/dbus/qdbusinterface.cpp
index fb958a8954..c1b0feea37 100644
--- a/src/dbus/qdbusinterface.cpp
+++ b/src/dbus/qdbusinterface.cpp
@@ -55,7 +55,7 @@ static void copyArgument(void *to, int id, const QVariant &arg)
 {
     if (id == arg.userType()) {
         switch (id) {
-        case QVariant::Bool:
+        case QMetaType::Bool:
             *reinterpret_cast<bool *>(to) = arg.toBool();
             return;
 
@@ -71,35 +71,35 @@ static void copyArgument(void *to, int id, const QVariant &arg)
             *reinterpret_cast<ushort *>(to) = qvariant_cast<ushort>(arg);
             return;
 
-        case QVariant::Int:
+        case QMetaType::Int:
             *reinterpret_cast<int *>(to) = arg.toInt();
             return;
 
-        case QVariant::UInt:
+        case QMetaType::UInt:
             *reinterpret_cast<uint *>(to) = arg.toUInt();
             return;
 
-        case QVariant::LongLong:
+        case QMetaType::LongLong:
             *reinterpret_cast<qlonglong *>(to) = arg.toLongLong();
             return;
 
-        case QVariant::ULongLong:
+        case QMetaType::ULongLong:
             *reinterpret_cast<qulonglong *>(to) = arg.toULongLong();
             return;
 
-        case QVariant::Double:
+        case QMetaType::Double:
             *reinterpret_cast<double *>(to) = arg.toDouble();
             return;
 
-        case QVariant::String:
+        case QMetaType::QString:
             *reinterpret_cast<QString *>(to) = arg.toString();
             return;
 
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             *reinterpret_cast<QByteArray *>(to) = arg.toByteArray();
             return;
 
-        case QVariant::StringList:
+        case QMetaType::QStringList:
             *reinterpret_cast<QStringList *>(to) = arg.toStringList();
             return;
         }
diff --git a/src/dbus/qdbusmarshaller.cpp b/src/dbus/qdbusmarshaller.cpp
index 46b41d1c07..c80131f41d 100644
--- a/src/dbus/qdbusmarshaller.cpp
+++ b/src/dbus/qdbusmarshaller.cpp
@@ -190,7 +190,7 @@ inline bool QDBusMarshaller::append(const QDBusVariant &arg)
 
     const QVariant &value = arg.variant();
     int id = value.userType();
-    if (id == QVariant::Invalid) {
+    if (id == QMetaType::UnknownType) {
         qWarning("QDBusMarshaller: cannot add a null QDBusVariant");
         error(QLatin1String("Variant containing QVariant::Invalid passed in arguments"));
         return false;
@@ -384,7 +384,7 @@ void QDBusMarshaller::error(const QString &msg)
 bool QDBusMarshaller::appendVariantInternal(const QVariant &arg)
 {
     int id = arg.userType();
-    if (id == QVariant::Invalid) {
+    if (id == QMetaType::UnknownType) {
         qWarning("QDBusMarshaller: cannot add an invalid QVariant");
         error(QLatin1String("Variant containing QVariant::Invalid passed in arguments"));
         return false;
@@ -485,12 +485,12 @@ bool QDBusMarshaller::appendVariantInternal(const QVariant &arg)
     case DBUS_TYPE_ARRAY:
         // could be many things
         // find out what kind of array it is
-        switch (arg.type()) {
-        case QVariant::StringList:
+        switch (arg.userType()) {
+        case QMetaType::QStringList:
             append( arg.toStringList() );
             return true;
 
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             append( arg.toByteArray() );
             return true;
 
diff --git a/src/dbus/qdbusmessage.cpp b/src/dbus/qdbusmessage.cpp
index 71cdec93ca..10d2f07d4d 100644
--- a/src/dbus/qdbusmessage.cpp
+++ b/src/dbus/qdbusmessage.cpp
@@ -276,7 +276,7 @@ QDBusMessage QDBusMessagePrivate::makeLocal(const QDBusConnectionPrivate &conn,
     for ( ; it != end; ++it) {
         int id = it->userType();
         const char *signature = QDBusMetaType::typeToSignature(id);
-        if ((id != QVariant::StringList && id != QVariant::ByteArray &&
+        if ((id != QMetaType::QStringList && id != QMetaType::QByteArray &&
              qstrlen(signature) != 1) || id == qMetaTypeId<QDBusVariant>()) {
             // yes, we are
             // we must marshall and demarshall again so as to create QDBusArgument
diff --git a/src/dbus/qdbusmetaobject.cpp b/src/dbus/qdbusmetaobject.cpp
index 3c529ab755..5265568f42 100644
--- a/src/dbus/qdbusmetaobject.cpp
+++ b/src/dbus/qdbusmetaobject.cpp
@@ -158,10 +158,10 @@ QDBusMetaObjectGenerator::findType(const QByteArray &signature,
                                    const char *direction, int id)
 {
     Type result;
-    result.id = QVariant::Invalid;
+    result.id = QMetaType::UnknownType;
 
     int type = QDBusMetaType::signatureToType(signature);
-    if (type == QVariant::Invalid && !qt_dbus_metaobject_skip_annotations) {
+    if (type == QMetaType::UnknownType && !qt_dbus_metaobject_skip_annotations) {
         // it's not a type normally handled by our meta type system
         // it must contain an annotation
         QString annotationName = QString::fromLatin1("org.qtproject.QtDBus.QtTypeName");
@@ -189,7 +189,7 @@ QDBusMetaObjectGenerator::findType(const QByteArray &signature,
             type = QMetaType::type(typeName);
         }
 
-        if (type == QVariant::Invalid || signature != QDBusMetaType::typeToSignature(type)) {
+        if (type == QMetaType::UnknownType || signature != QDBusMetaType::typeToSignature(type)) {
             // type is still unknown or doesn't match back to the signature that it
             // was expected to, so synthesize a fake type
             typeName = "QDBusRawType<0x" + signature.toHex() + ">*";
@@ -197,16 +197,16 @@ QDBusMetaObjectGenerator::findType(const QByteArray &signature,
         }
 
         result.name = typeName;
-    } else if (type == QVariant::Invalid) {
+    } else if (type == QMetaType::UnknownType) {
         // this case is used only by the qdbus command-line tool
         // invalid, let's create an impossible type that contains the signature
 
         if (signature == "av") {
             result.name = "QVariantList";
-            type = QVariant::List;
+            type = QMetaType::QVariantList;
         } else if (signature == "a{sv}") {
             result.name = "QVariantMap";
-            type = QVariant::Map;
+            type = QMetaType::QVariantMap;
         } else if (signature == "a{ss}") {
             result.name = "QMap<QString,QString>";
             type = qMetaTypeId<QMap<QString, QString> >();
@@ -246,7 +246,7 @@ void QDBusMetaObjectGenerator::parseMethods()
             const QDBusIntrospection::Argument &arg = m.inputArgs.at(i);
 
             Type type = findType(arg.type.toLatin1(), m.annotations, "In", i);
-            if (type.id == QVariant::Invalid) {
+            if (type.id == QMetaType::UnknownType) {
                 ok = false;
                 break;
             }
@@ -265,7 +265,7 @@ void QDBusMetaObjectGenerator::parseMethods()
             const QDBusIntrospection::Argument &arg = m.outputArgs.at(i);
 
             Type type = findType(arg.type.toLatin1(), m.annotations, "Out", i);
-            if (type.id == QVariant::Invalid) {
+            if (type.id == QMetaType::UnknownType) {
                 ok = false;
                 break;
             }
@@ -322,7 +322,7 @@ void QDBusMetaObjectGenerator::parseSignals()
             const QDBusIntrospection::Argument &arg = s.outputArgs.at(i);
 
             Type type = findType(arg.type.toLatin1(), s.annotations, "Out", i);
-            if (type.id == QVariant::Invalid) {
+            if (type.id == QMetaType::UnknownType) {
                 ok = false;
                 break;
             }
@@ -358,7 +358,7 @@ void QDBusMetaObjectGenerator::parseProperties()
         const QDBusIntrospection::Property &p = *prop_it;
         Property mp;
         Type type = findType(p.type.toLatin1(), p.annotations);
-        if (type.id == QVariant::Invalid)
+        if (type.id == QMetaType::UnknownType)
             continue;
 
         QByteArray name = p.name.toLatin1();
diff --git a/src/dbus/qdbusmetatype.cpp b/src/dbus/qdbusmetatype.cpp
index e3804f74f8..bcbb22fba6 100644
--- a/src/dbus/qdbusmetatype.cpp
+++ b/src/dbus/qdbusmetatype.cpp
@@ -325,7 +325,7 @@ int QDBusMetaType::signatureToType(const char *signature)
     switch (signature[0])
     {
     case DBUS_TYPE_BOOLEAN:
-        return QVariant::Bool;
+        return QMetaType::Bool;
 
     case DBUS_TYPE_BYTE:
         return QMetaType::UChar;
@@ -337,22 +337,22 @@ int QDBusMetaType::signatureToType(const char *signature)
         return QMetaType::UShort;
 
     case DBUS_TYPE_INT32:
-        return QVariant::Int;
+        return QMetaType::Int;
 
     case DBUS_TYPE_UINT32:
-        return QVariant::UInt;
+        return QMetaType::UInt;
 
     case DBUS_TYPE_INT64:
-        return QVariant::LongLong;
+        return QMetaType::LongLong;
 
     case DBUS_TYPE_UINT64:
-        return QVariant::ULongLong;
+        return QMetaType::ULongLong;
 
     case DBUS_TYPE_DOUBLE:
-        return QVariant::Double;
+        return QMetaType::Double;
 
     case DBUS_TYPE_STRING:
-        return QVariant::String;
+        return QMetaType::QString;
 
     case DBUS_TYPE_OBJECT_PATH:
         return QDBusMetaTypeId::objectpath();
@@ -369,13 +369,13 @@ int QDBusMetaType::signatureToType(const char *signature)
     case DBUS_TYPE_ARRAY:       // special case
         switch (signature[1]) {
         case DBUS_TYPE_BYTE:
-            return QVariant::ByteArray;
+            return QMetaType::QByteArray;
 
         case DBUS_TYPE_STRING:
-            return QVariant::StringList;
+            return QMetaType::QStringList;
 
         case DBUS_TYPE_VARIANT:
-            return QVariant::List;
+            return QMetaType::QVariantList;
 
         case DBUS_TYPE_OBJECT_PATH:
             return qMetaTypeId<QList<QDBusObjectPath> >();
@@ -409,7 +409,7 @@ const char *QDBusMetaType::typeToSignature(int type)
     case QMetaType::UChar:
         return DBUS_TYPE_BYTE_AS_STRING;
 
-    case QVariant::Bool:
+    case QMetaType::Bool:
         return DBUS_TYPE_BOOLEAN_AS_STRING;
 
     case QMetaType::Short:
@@ -418,29 +418,29 @@ const char *QDBusMetaType::typeToSignature(int type)
     case QMetaType::UShort:
         return DBUS_TYPE_UINT16_AS_STRING;
 
-    case QVariant::Int:
+    case QMetaType::Int:
         return DBUS_TYPE_INT32_AS_STRING;
 
-    case QVariant::UInt:
+    case QMetaType::UInt:
         return DBUS_TYPE_UINT32_AS_STRING;
 
-    case QVariant::LongLong:
+    case QMetaType::LongLong:
         return DBUS_TYPE_INT64_AS_STRING;
 
-    case QVariant::ULongLong:
+    case QMetaType::ULongLong:
         return DBUS_TYPE_UINT64_AS_STRING;
 
-    case QVariant::Double:
+    case QMetaType::Double:
         return DBUS_TYPE_DOUBLE_AS_STRING;
 
-    case QVariant::String:
+    case QMetaType::QString:
         return DBUS_TYPE_STRING_AS_STRING;
 
-    case QVariant::StringList:
+    case QMetaType::QStringList:
         return DBUS_TYPE_ARRAY_AS_STRING
             DBUS_TYPE_STRING_AS_STRING; // as
 
-    case QVariant::ByteArray:
+    case QMetaType::QByteArray:
         return DBUS_TYPE_ARRAY_AS_STRING
             DBUS_TYPE_BYTE_AS_STRING; // ay
     }
diff --git a/src/dbus/qdbusutil.cpp b/src/dbus/qdbusutil.cpp
index 09311d1ad4..b4ee6811ac 100644
--- a/src/dbus/qdbusutil.cpp
+++ b/src/dbus/qdbusutil.cpp
@@ -82,7 +82,7 @@ static bool variantToString(const QVariant &arg, QString &out)
 {
     int argType = arg.userType();
 
-    if (argType == QVariant::StringList) {
+    if (argType == QMetaType::QStringList) {
         out += QLatin1Char('{');
         const QStringList list = arg.toStringList();
         for (const QString &item : list)
@@ -90,7 +90,7 @@ static bool variantToString(const QVariant &arg, QString &out)
         if (!list.isEmpty())
             out.chop(2);
         out += QLatin1Char('}');
-    } else if (argType == QVariant::ByteArray) {
+    } else if (argType == QMetaType::QByteArray) {
         out += QLatin1Char('{');
         QByteArray list = arg.toByteArray();
         for (int i = 0; i < list.count(); ++i) {
@@ -100,7 +100,7 @@ static bool variantToString(const QVariant &arg, QString &out)
         if (!list.isEmpty())
             out.chop(2);
         out += QLatin1Char('}');
-    } else if (argType == QVariant::List) {
+    } else if (argType == QMetaType::QVariantList) {
         out += QLatin1Char('{');
         const QList<QVariant> list = arg.toList();
         for (const QVariant &item : list) {
@@ -148,7 +148,7 @@ static bool variantToString(const QVariant &arg, QString &out)
         if (!variantToString(v, out))
             return false;
         out += QLatin1Char(']');
-    } else if (arg.canConvert(QVariant::String)) {
+    } else if (arg.canConvert(QMetaType::QString)) {
         out += QLatin1Char('\"') + arg.toString() + QLatin1Char('\"');
     } else {
         out += QLatin1Char('[');
diff --git a/src/dbus/qdbusxmlgenerator.cpp b/src/dbus/qdbusxmlgenerator.cpp
index c6b3b90508..7370ce0de3 100644
--- a/src/dbus/qdbusxmlgenerator.cpp
+++ b/src/dbus/qdbusxmlgenerator.cpp
@@ -113,7 +113,7 @@ static QString generateInterfaceXml(const QMetaObject *mo, int flags, int method
                            QLatin1String(signature),
                            accessAsString(mp.isReadable(), mp.isWritable()));
 
-            if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) {
+            if (QDBusMetaType::signatureToType(signature) == QMetaType::UnknownType) {
                 const char *typeName = QMetaType::typeName(typeId);
                 retval += QLatin1String(">\n      <annotation name=\"org.qtproject.QtDBus.QtTypeName\" value=\"%3\"/>\n    </property>\n")
                           .arg(typeNameToXml(typeName));
@@ -161,7 +161,7 @@ static QString generateInterfaceXml(const QMetaObject *mo, int flags, int method
                        .arg(typeNameToXml(typeName));
 
                 // do we need to describe this argument?
-                if (QDBusMetaType::signatureToType(typeName) == QVariant::Invalid)
+                if (QDBusMetaType::signatureToType(typeName) == QMetaType::UnknownType)
                     xml += QLatin1String("      <annotation name=\"org.qtproject.QtDBus.QtTypeName.Out0\" value=\"%1\"/>\n")
                         .arg(typeNameToXml(QMetaType::typeName(typeId)));
             } else {
@@ -208,7 +208,7 @@ static QString generateInterfaceXml(const QMetaObject *mo, int flags, int method
                                      qUtf16Printable(name), signature, isOutput ? "out" : "in");
 
             // do we need to describe this argument?
-            if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) {
+            if (QDBusMetaType::signatureToType(signature) == QMetaType::UnknownType) {
                 const char *typeName = QMetaType::typeName(types.at(j));
                 xml += QString::fromLatin1("      <annotation name=\"org.qtproject.QtDBus.QtTypeName.%1%2\" value=\"%3\"/>\n")
                        .arg(isOutput ? QLatin1String("Out") : QLatin1String("In"))