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>

15 files changed, 393 insertions, 393 deletions

diff --git a/src/corelib/animation/qpropertyanimation.cpp b/src/corelib/animation/qpropertyanimation.cpp
index c71a77e073..d014b5c441 100644
--- a/src/corelib/animation/qpropertyanimation.cpp
+++ b/src/corelib/animation/qpropertyanimation.cpp
@@ -92,7 +92,7 @@ QT_BEGIN_NAMESPACE
 void QPropertyAnimationPrivate::updateMetaProperty()
 {
     if (!target || propertyName.isEmpty()) {
-        propertyType = QVariant::Invalid;
+        propertyType = QMetaType::UnknownType;
         propertyIndex = -1;
         return;
     }
@@ -102,11 +102,11 @@ void QPropertyAnimationPrivate::updateMetaProperty()
     propertyType = targetValue->property(propertyName).userType();
     propertyIndex = targetValue->metaObject()->indexOfProperty(propertyName);
 
-    if (propertyType != QVariant::Invalid)
+    if (propertyType != QMetaType::UnknownType)
         convertValues(propertyType);
     if (propertyIndex == -1) {
         //there is no Q_PROPERTY on the object
-        propertyType = QVariant::Invalid;
+        propertyType = QMetaType::UnknownType;
         if (!targetValue->dynamicPropertyNames().contains(propertyName))
             qWarning("QPropertyAnimation: you're trying to animate a non-existing property %s of your QObject", propertyName.constData());
     } else if (!targetValue->metaObject()->property(propertyIndex).isWritable()) {
diff --git a/src/corelib/io/qsettings.cpp b/src/corelib/io/qsettings.cpp
index 9fc45e307d..b191397e7e 100644
--- a/src/corelib/io/qsettings.cpp
+++ b/src/corelib/io/qsettings.cpp
@@ -396,12 +396,12 @@ QString QSettingsPrivate::variantToString(const QVariant &v)
 {
     QString result;
 
-    switch (v.type()) {
-        case QVariant::Invalid:
+    switch (v.userType()) {
+        case QMetaType::UnknownType:
             result = QLatin1String("@Invalid()");
             break;
 
-        case QVariant::ByteArray: {
+        case QMetaType::QByteArray: {
             QByteArray a = v.toByteArray();
             result = QLatin1String("@ByteArray(")
                      + QLatin1String(a.constData(), a.size())
@@ -409,14 +409,14 @@ QString QSettingsPrivate::variantToString(const QVariant &v)
             break;
         }
 
-        case QVariant::String:
-        case QVariant::LongLong:
-        case QVariant::ULongLong:
-        case QVariant::Int:
-        case QVariant::UInt:
-        case QVariant::Bool:
-        case QVariant::Double:
-        case QVariant::KeySequence: {
+        case QMetaType::QString:
+        case QMetaType::LongLong:
+        case QMetaType::ULongLong:
+        case QMetaType::Int:
+        case QMetaType::UInt:
+        case QMetaType::Bool:
+        case QMetaType::Double:
+        case QMetaType::QKeySequence: {
             result = v.toString();
             if (result.contains(QChar::Null))
                 result = QLatin1String("@String(") + result + QLatin1Char(')');
@@ -425,17 +425,17 @@ QString QSettingsPrivate::variantToString(const QVariant &v)
             break;
         }
 #ifndef QT_NO_GEOM_VARIANT
-        case QVariant::Rect: {
+        case QMetaType::QRect: {
             QRect r = qvariant_cast<QRect>(v);
             result = QString::asprintf("@Rect(%d %d %d %d)", r.x(), r.y(), r.width(), r.height());
             break;
         }
-        case QVariant::Size: {
+        case QMetaType::QSize: {
             QSize s = qvariant_cast<QSize>(v);
             result = QString::asprintf("@Size(%d %d)", s.width(), s.height());
             break;
         }
-        case QVariant::Point: {
+        case QMetaType::QPoint: {
             QPoint p = qvariant_cast<QPoint>(v);
             result = QString::asprintf("@Point(%d %d)", p.x(), p.y());
             break;
@@ -446,7 +446,7 @@ QString QSettingsPrivate::variantToString(const QVariant &v)
 #ifndef QT_NO_DATASTREAM
             QDataStream::Version version;
             const char *typeSpec;
-            if (v.type() == QVariant::DateTime) {
+            if (v.userType() == QMetaType::QDateTime) {
                 version = QDataStream::Qt_5_6;
                 typeSpec = "@DateTime(";
             } else {
@@ -1888,8 +1888,8 @@ bool QConfFileSettingsPrivate::writeIniFile(QIODevice &device, const ParsedSetti
                 QVariant(QString("foo")).toList() returns an empty
                 list, not a list containing "foo".
             */
-            if (value.type() == QVariant::StringList
-                    || (value.type() == QVariant::List && value.toList().size() != 1)) {
+            if (value.userType() == QMetaType::QStringList
+                    || (value.userType() == QMetaType::QVariantList && value.toList().size() != 1)) {
                 iniEscapedStringList(variantListToStringList(value.toList()), block, iniCodec);
             } else {
                 iniEscapedString(variantToString(value), block, iniCodec);
diff --git a/src/corelib/itemmodels/qabstractitemmodel.cpp b/src/corelib/itemmodels/qabstractitemmodel.cpp
index 46ac703615..608407c136 100644
--- a/src/corelib/itemmodels/qabstractitemmodel.cpp
+++ b/src/corelib/itemmodels/qabstractitemmodel.cpp
@@ -552,32 +552,32 @@ const QHash<int,QByteArray> &QAbstractItemModelPrivate::defaultRoleNames()
 bool QAbstractItemModelPrivate::isVariantLessThan(const QVariant &left, const QVariant &right,
                                                   Qt::CaseSensitivity cs, bool isLocaleAware)
 {
-    if (left.userType() == QVariant::Invalid)
+    if (left.userType() == QMetaType::UnknownType)
         return false;
-    if (right.userType() == QVariant::Invalid)
+    if (right.userType() == QMetaType::UnknownType)
         return true;
     switch (left.userType()) {
-    case QVariant::Int:
+    case QMetaType::Int:
         return left.toInt() < right.toInt();
-    case QVariant::UInt:
+    case QMetaType::UInt:
         return left.toUInt() < right.toUInt();
-    case QVariant::LongLong:
+    case QMetaType::LongLong:
         return left.toLongLong() < right.toLongLong();
-    case QVariant::ULongLong:
+    case QMetaType::ULongLong:
         return left.toULongLong() < right.toULongLong();
     case QMetaType::Float:
         return left.toFloat() < right.toFloat();
-    case QVariant::Double:
+    case QMetaType::Double:
         return left.toDouble() < right.toDouble();
-    case QVariant::Char:
+    case QMetaType::QChar:
         return left.toChar() < right.toChar();
-    case QVariant::Date:
+    case QMetaType::QDate:
         return left.toDate() < right.toDate();
-    case QVariant::Time:
+    case QMetaType::QTime:
         return left.toTime() < right.toTime();
-    case QVariant::DateTime:
+    case QMetaType::QDateTime:
         return left.toDateTime() < right.toDateTime();
-    case QVariant::String:
+    case QMetaType::QString:
     default:
         if (isLocaleAware)
             return left.toString().localeAwareCompare(right.toString()) < 0;
@@ -591,19 +591,19 @@ static uint typeOfVariant(const QVariant &value)
 {
     //return 0 for integer, 1 for floating point and 2 for other
     switch (value.userType()) {
-        case QVariant::Bool:
-        case QVariant::Int:
-        case QVariant::UInt:
-        case QVariant::LongLong:
-        case QVariant::ULongLong:
-        case QVariant::Char:
+        case QMetaType::Bool:
+        case QMetaType::Int:
+        case QMetaType::UInt:
+        case QMetaType::LongLong:
+        case QMetaType::ULongLong:
+        case QMetaType::QChar:
         case QMetaType::Short:
         case QMetaType::UShort:
         case QMetaType::UChar:
         case QMetaType::ULong:
         case QMetaType::Long:
             return 0;
-        case QVariant::Double:
+        case QMetaType::Double:
         case QMetaType::Float:
             return 1;
         default:
@@ -2379,7 +2379,7 @@ QModelIndexList QAbstractItemModel::match(const QModelIndex &start, int role,
             } else { // QString or regular expression based matching
                 if (matchType == Qt::MatchRegularExpression) {
                     if (rx.pattern().isEmpty()) {
-                        if (value.type() == QVariant::RegularExpression) {
+                        if (value.userType() == QMetaType::QRegularExpression) {
                             rx = value.toRegularExpression();
                         } else {
                             rx.setPattern(value.toString());
diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp
index fad47eee13..347fb1eb87 100644
--- a/src/corelib/kernel/qmetaobject.cpp
+++ b/src/corelib/kernel/qmetaobject.cpp
@@ -2982,7 +2982,7 @@ int QMetaProperty::userType() const
         if (type == QMetaType::UnknownType) {
             type = registerPropertyType();
             if (type == QMetaType::UnknownType)
-                return QVariant::Int; // Match behavior of QMetaType::type()
+                return QMetaType::Int; // Match behavior of QMetaType::type()
         }
         return type;
     }
@@ -3100,7 +3100,7 @@ QVariant QMetaProperty::read(const QObject *object) const
     if (!object || !mobj)
         return QVariant();
 
-    uint t = QVariant::Int;
+    uint t = QMetaType::Int;
     if (isEnumType()) {
         /*
           try to create a QVariant that can be converted to this enum
@@ -3177,9 +3177,9 @@ bool QMetaProperty::write(QObject *object, const QVariant &value) const
         return false;
 
     QVariant v = value;
-    uint t = QVariant::Invalid;
+    uint t = QMetaType::UnknownType;
     if (isEnumType()) {
-        if (v.type() == QVariant::String) {
+        if (v.userType() == QMetaType::QString) {
             bool ok;
             if (isFlagType())
                 v = QVariant(menum.keysToValue(value.toByteArray(), &ok));
@@ -3187,13 +3187,13 @@ bool QMetaProperty::write(QObject *object, const QVariant &value) const
                 v = QVariant(menum.keyToValue(value.toByteArray(), &ok));
             if (!ok)
                 return false;
-        } else if (v.type() != QVariant::Int && v.type() != QVariant::UInt) {
+        } else if (v.userType() != QMetaType::Int && v.userType() != QMetaType::UInt) {
             int enumMetaTypeId = QMetaType::type(qualifiedName(menum));
             if ((enumMetaTypeId == QMetaType::UnknownType) || (v.userType() != enumMetaTypeId) || !v.constData())
                 return false;
             v = QVariant(*reinterpret_cast<const int *>(v.constData()));
         }
-        v.convert(QVariant::Int);
+        v.convert(QMetaType::Int);
     } else {
         int handle = priv(mobj->d.data)->propertyData + 3*idx;
         const char *typeName = nullptr;
diff --git a/src/corelib/kernel/qmimedata.cpp b/src/corelib/kernel/qmimedata.cpp
index 00e5183eb1..fca258c9e3 100644
--- a/src/corelib/kernel/qmimedata.cpp
+++ b/src/corelib/kernel/qmimedata.cpp
@@ -70,7 +70,7 @@ public:
     void setData(const QString &format, const QVariant &data);
     QVariant getData(const QString &format) const;
 
-    QVariant retrieveTypedData(const QString &format, QVariant::Type type) const;
+    QVariant retrieveTypedData(const QString &format, QMetaType::Type type) const;
 
     QVector<QMimeDataStruct> dataList;
 };
@@ -108,23 +108,23 @@ QVariant QMimeDataPrivate::getData(const QString &format) const
     return data;
 }
 
-QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Type type) const
+QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QMetaType::Type type) const
 {
     Q_Q(const QMimeData);
 
-    QVariant data = q->retrieveData(format, type);
+    QVariant data = q->retrieveData(format, QVariant::Type(type));
 
     // Text data requested: fallback to URL data if available
     if (format == QLatin1String("text/plain") && !data.isValid()) {
-        data = retrieveTypedData(textUriListLiteral(), QVariant::List);
-        if (data.type() == QVariant::Url) {
+        data = retrieveTypedData(textUriListLiteral(), QMetaType::QVariantList);
+        if (data.userType() == QMetaType::QUrl) {
             data = QVariant(data.toUrl().toDisplayString());
-        } else if (data.type() == QVariant::List) {
+        } else if (data.userType() == QMetaType::QVariantList) {
             QString text;
             int numUrls = 0;
             const QList<QVariant> list = data.toList();
             for (int i = 0; i < list.size(); ++i) {
-                if (list.at(i).type() == QVariant::Url) {
+                if (list.at(i).userType() == QMetaType::QUrl) {
                     text += list.at(i).toUrl().toDisplayString() + QLatin1Char('\n');
                     ++numUrls;
                 }
@@ -135,26 +135,26 @@ QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Ty
         }
     }
 
-    if (data.type() == type || !data.isValid())
+    if (data.userType() == type || !data.isValid())
         return data;
 
     // provide more conversion possiblities than just what QVariant provides
 
     // URLs can be lists as well...
-    if ((type == QVariant::Url && data.type() == QVariant::List)
-        || (type == QVariant::List && data.type() == QVariant::Url))
+    if ((type == QMetaType::QUrl && data.userType() == QMetaType::QVariantList)
+        || (type == QMetaType::QVariantList && data.userType() == QMetaType::QUrl))
         return data;
 
     // images and pixmaps are interchangeable
-    if ((type == QVariant::Pixmap && data.type() == QVariant::Image)
-        || (type == QVariant::Image && data.type() == QVariant::Pixmap))
+    if ((type == QMetaType::QPixmap && data.userType() == QMetaType::QImage)
+        || (type == QMetaType::QImage && data.userType() == QMetaType::QPixmap))
         return data;
 
-    if (data.type() == QVariant::ByteArray) {
+    if (data.userType() == QMetaType::QByteArray) {
         // see if we can convert to the requested type
         switch(type) {
 #if QT_CONFIG(textcodec)
-        case QVariant::String: {
+        case QMetaType::QString: {
             const QByteArray ba = data.toByteArray();
             QTextCodec *codec = QTextCodec::codecForName("utf-8");
             if (format == QLatin1String("text/html"))
@@ -162,17 +162,17 @@ QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Ty
             return codec->toUnicode(ba);
         }
 #endif // textcodec
-        case QVariant::Color: {
+        case QMetaType::QColor: {
             QVariant newData = data;
-            newData.convert(QVariant::Color);
+            newData.convert(QMetaType::QColor);
             return newData;
         }
-        case QVariant::List: {
+        case QMetaType::QVariantList: {
             if (format != QLatin1String("text/uri-list"))
                 break;
             Q_FALLTHROUGH();
         }
-        case QVariant::Url: {
+        case QMetaType::QUrl: {
             QByteArray ba = data.toByteArray();
             // Qt 3.x will send text/uri-list with a trailing
             // null-terminator (that is *not* sent for any other
@@ -193,23 +193,23 @@ QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Ty
             break;
         }
 
-    } else if (type == QVariant::ByteArray) {
+    } else if (type == QMetaType::QByteArray) {
 
         // try to convert to bytearray
-        switch(data.type()) {
-        case QVariant::ByteArray:
-        case QVariant::Color:
+        switch (data.userType()) {
+        case QMetaType::QByteArray:
+        case QMetaType::QColor:
             return data.toByteArray();
-        case QVariant::String:
+        case QMetaType::QString:
             return data.toString().toUtf8();
-        case QVariant::Url:
+        case QMetaType::QUrl:
             return data.toUrl().toEncoded();
-        case QVariant::List: {
+        case QMetaType::QVariantList: {
             // has to be list of URLs
             QByteArray result;
             QList<QVariant> list = data.toList();
             for (int i = 0; i < list.size(); ++i) {
-                if (list.at(i).type() == QVariant::Url) {
+                if (list.at(i).userType() == QMetaType::QUrl) {
                     result += list.at(i).toUrl().toEncoded();
                     result += "\r\n";
                 }
@@ -340,14 +340,14 @@ QMimeData::~QMimeData()
 QList<QUrl> QMimeData::urls() const
 {
     Q_D(const QMimeData);
-    QVariant data = d->retrieveTypedData(textUriListLiteral(), QVariant::List);
+    QVariant data = d->retrieveTypedData(textUriListLiteral(), QMetaType::QVariantList);
     QList<QUrl> urls;
-    if (data.type() == QVariant::Url)
+    if (data.userType() == QMetaType::QUrl)
         urls.append(data.toUrl());
-    else if (data.type() == QVariant::List) {
+    else if (data.userType() == QMetaType::QVariantList) {
         QList<QVariant> list = data.toList();
         for (int i = 0; i < list.size(); ++i) {
-            if (list.at(i).type() == QVariant::Url)
+            if (list.at(i).userType() == QMetaType::QUrl)
                 urls.append(list.at(i).toUrl());
         }
     }
@@ -400,11 +400,11 @@ bool QMimeData::hasUrls() const
 QString QMimeData::text() const
 {
     Q_D(const QMimeData);
-    QVariant utf8Text = d->retrieveTypedData(textPlainUtf8Literal(), QVariant::String);
+    QVariant utf8Text = d->retrieveTypedData(textPlainUtf8Literal(), QMetaType::QString);
     if (!utf8Text.isNull())
         return utf8Text.toString();
 
-    QVariant data = d->retrieveTypedData(textPlainLiteral(), QVariant::String);
+    QVariant data = d->retrieveTypedData(textPlainLiteral(), QMetaType::QString);
     return data.toString();
 }
 
@@ -440,7 +440,7 @@ bool QMimeData::hasText() const
 QString QMimeData::html() const
 {
     Q_D(const QMimeData);
-    QVariant data = d->retrieveTypedData(textHtmlLiteral(), QVariant::String);
+    QVariant data = d->retrieveTypedData(textHtmlLiteral(), QMetaType::QString);
     return data.toString();
 }
 
@@ -482,7 +482,7 @@ bool QMimeData::hasHtml() const
 QVariant QMimeData::imageData() const
 {
     Q_D(const QMimeData);
-    return d->retrieveTypedData(applicationXQtImageLiteral(), QVariant::Image);
+    return d->retrieveTypedData(applicationXQtImageLiteral(), QMetaType::QImage);
 }
 
 /*!
@@ -529,7 +529,7 @@ bool QMimeData::hasImage() const
 QVariant QMimeData::colorData() const
 {
     Q_D(const QMimeData);
-    return d->retrieveTypedData(applicationXColorLiteral(), QVariant::Color);
+    return d->retrieveTypedData(applicationXColorLiteral(), QMetaType::QColor);
 }
 
 /*!
@@ -564,7 +564,7 @@ bool QMimeData::hasColor() const
 QByteArray QMimeData::data(const QString &mimeType) const
 {
     Q_D(const QMimeData);
-    QVariant data = d->retrieveTypedData(mimeType, QVariant::ByteArray);
+    QVariant data = d->retrieveTypedData(mimeType, QMetaType::QByteArray);
     return data.toByteArray();
 }
 
diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp
index f3ac3fcdba..b417683d2a 100644
--- a/src/corelib/kernel/qvariant.cpp
+++ b/src/corelib/kernel/qvariant.cpp
@@ -168,7 +168,7 @@ static qlonglong qMetaTypeNumber(const QVariant::Private *d)
         return qlonglong(d->data.l);
     case QMetaType::Float:
         return qRound64(d->data.f);
-    case QVariant::Double:
+    case QMetaType::Double:
         return qRound64(d->data.d);
 #ifndef QT_BOOTSTRAPPED
     case QMetaType::QJsonValue:
@@ -184,9 +184,9 @@ static qlonglong qMetaTypeNumber(const QVariant::Private *d)
 static qulonglong qMetaTypeUNumber(const QVariant::Private *d)
 {
     switch (d->type) {
-    case QVariant::UInt:
+    case QMetaType::UInt:
         return d->data.u;
-    case QVariant::ULongLong:
+    case QMetaType::ULongLong:
         return d->data.ull;
     case QMetaType::UChar:
         return d->data.uc;
@@ -204,13 +204,13 @@ static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok)
     *ok = true;
 
     switch (uint(d->type)) {
-    case QVariant::String:
+    case QMetaType::QString:
         return v_cast<QString>(d)->toLongLong(ok);
-    case QVariant::Char:
+    case QMetaType::QChar:
         return v_cast<QChar>(d)->unicode();
-    case QVariant::ByteArray:
+    case QMetaType::QByteArray:
         return v_cast<QByteArray>(d)->toLongLong(ok);
-    case QVariant::Bool:
+    case QMetaType::Bool:
         return qlonglong(d->data.b);
 #ifndef QT_BOOTSTRAPPED
     case QMetaType::QCborValue:
@@ -222,8 +222,8 @@ static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok)
             break;
         Q_FALLTHROUGH();
 #endif
-    case QVariant::Double:
-    case QVariant::Int:
+    case QMetaType::Double:
+    case QMetaType::Int:
     case QMetaType::Char:
     case QMetaType::SChar:
     case QMetaType::Short:
@@ -231,8 +231,8 @@ static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok)
     case QMetaType::Float:
     case QMetaType::LongLong:
         return qMetaTypeNumber(d);
-    case QVariant::ULongLong:
-    case QVariant::UInt:
+    case QMetaType::ULongLong:
+    case QMetaType::UInt:
     case QMetaType::UChar:
     case QMetaType::UShort:
     case QMetaType::ULong:
@@ -262,12 +262,12 @@ static qreal qConvertToRealNumber(const QVariant::Private *d, bool *ok)
 {
     *ok = true;
     switch (uint(d->type)) {
-    case QVariant::Double:
+    case QMetaType::Double:
         return qreal(d->data.d);
     case QMetaType::Float:
         return qreal(d->data.f);
-    case QVariant::ULongLong:
-    case QVariant::UInt:
+    case QMetaType::ULongLong:
+    case QMetaType::UInt:
     case QMetaType::UChar:
     case QMetaType::UShort:
     case QMetaType::ULong:
@@ -289,13 +289,13 @@ static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok)
     *ok = true;
 
     switch (uint(d->type)) {
-    case QVariant::String:
+    case QMetaType::QString:
         return v_cast<QString>(d)->toULongLong(ok);
-    case QVariant::Char:
+    case QMetaType::QChar:
         return v_cast<QChar>(d)->unicode();
-    case QVariant::ByteArray:
+    case QMetaType::QByteArray:
         return v_cast<QByteArray>(d)->toULongLong(ok);
-    case QVariant::Bool:
+    case QMetaType::Bool:
         return qulonglong(d->data.b);
 #ifndef QT_BOOTSTRAPPED
     case QMetaType::QCborValue:
@@ -309,8 +309,8 @@ static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok)
             break;
         Q_FALLTHROUGH();
 #endif
-    case QVariant::Double:
-    case QVariant::Int:
+    case QMetaType::Double:
+    case QMetaType::Int:
     case QMetaType::Char:
     case QMetaType::SChar:
     case QMetaType::Short:
@@ -318,8 +318,8 @@ static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok)
     case QMetaType::Float:
     case QMetaType::LongLong:
         return qulonglong(qMetaTypeNumber(d));
-    case QVariant::ULongLong:
-    case QVariant::UInt:
+    case QMetaType::ULongLong:
+    case QMetaType::UInt:
     case QMetaType::UChar:
     case QMetaType::UShort:
     case QMetaType::ULong:
@@ -406,9 +406,9 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
 
     switch (uint(t)) {
 #ifndef QT_BOOTSTRAPPED
-    case QVariant::Url:
+    case QMetaType::QUrl:
         switch (d->type) {
-        case QVariant::String:
+        case QMetaType::QString:
             *static_cast<QUrl *>(result) = QUrl(*v_cast<QString>(d));
             break;
         case QMetaType::QCborValue:
@@ -423,18 +423,18 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
 #endif // QT_BOOTSTRAPPED
 #if QT_CONFIG(itemmodel)
-    case QVariant::ModelIndex:
+    case QMetaType::QModelIndex:
         switch (d->type) {
-        case QVariant::PersistentModelIndex:
+        case QMetaType::QPersistentModelIndex:
             *static_cast<QModelIndex *>(result) = QModelIndex(*v_cast<QPersistentModelIndex>(d));
             break;
         default:
             return false;
         }
         break;
-    case QVariant::PersistentModelIndex:
+    case QMetaType::QPersistentModelIndex:
         switch (d->type) {
-        case QVariant::ModelIndex:
+        case QMetaType::QModelIndex:
             *static_cast<QPersistentModelIndex *>(result) = QPersistentModelIndex(*v_cast<QModelIndex>(d));
             break;
         default:
@@ -442,10 +442,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         }
         break;
 #endif // QT_CONFIG(itemmodel)
-    case QVariant::String: {
+    case QMetaType::QString: {
         QString *str = static_cast<QString *>(result);
         switch (d->type) {
-        case QVariant::Char:
+        case QMetaType::QChar:
             *str = *v_cast<QChar>(d);
             break;
         case QMetaType::Char:
@@ -455,12 +455,12 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
             break;
         case QMetaType::Short:
         case QMetaType::Long:
-        case QVariant::Int:
-        case QVariant::LongLong:
+        case QMetaType::Int:
+        case QMetaType::LongLong:
             *str = QString::number(qMetaTypeNumber(d));
             break;
-        case QVariant::UInt:
-        case QVariant::ULongLong:
+        case QMetaType::UInt:
+        case QMetaType::ULongLong:
         case QMetaType::UShort:
         case QMetaType::ULong:
             *str = QString::number(qMetaTypeUNumber(d));
@@ -468,32 +468,32 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         case QMetaType::Float:
             *str = QString::number(d->data.f, 'g', QLocale::FloatingPointShortest);
             break;
-        case QVariant::Double:
+        case QMetaType::Double:
             *str = QString::number(d->data.d, 'g', QLocale::FloatingPointShortest);
             break;
 #if QT_CONFIG(datestring)
-        case QVariant::Date:
+        case QMetaType::QDate:
             *str = v_cast<QDate>(d)->toString(Qt::ISODate);
             break;
-        case QVariant::Time:
+        case QMetaType::QTime:
             *str = v_cast<QTime>(d)->toString(Qt::ISODateWithMs);
             break;
-        case QVariant::DateTime:
+        case QMetaType::QDateTime:
             *str = v_cast<QDateTime>(d)->toString(Qt::ISODateWithMs);
             break;
 #endif
-        case QVariant::Bool:
+        case QMetaType::Bool:
             *str = d->data.b ? QStringLiteral("true") : QStringLiteral("false");
             break;
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             *str = QString::fromUtf8(v_cast<QByteArray>(d)->constData());
             break;
-        case QVariant::StringList:
+        case QMetaType::QStringList:
             if (v_cast<QStringList>(d)->count() == 1)
                 *str = v_cast<QStringList>(d)->at(0);
             break;
 #ifndef QT_BOOTSTRAPPED
-        case QVariant::Url:
+        case QMetaType::QUrl:
             *str = v_cast<QUrl>(d)->toString();
             break;
         case QMetaType::QJsonValue:
@@ -508,7 +508,7 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
             *str = v_cast<QCborValue>(d)->toVariant().toString();
             break;
 #endif
-        case QVariant::Uuid:
+        case QMetaType::QUuid:
             *str = v_cast<QUuid>(d)->toString();
             break;
         case QMetaType::Nullptr:
@@ -528,11 +528,11 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         }
         break;
     }
-    case QVariant::Char: {
+    case QMetaType::QChar: {
         QChar *c = static_cast<QChar *>(result);
         switch (d->type) {
-        case QVariant::Int:
-        case QVariant::LongLong:
+        case QMetaType::Int:
+        case QMetaType::LongLong:
         case QMetaType::Char:
         case QMetaType::SChar:
         case QMetaType::Short:
@@ -540,8 +540,8 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         case QMetaType::Float:
             *c = QChar(ushort(qMetaTypeNumber(d)));
             break;
-        case QVariant::UInt:
-        case QVariant::ULongLong:
+        case QMetaType::UInt:
+        case QMetaType::ULongLong:
         case QMetaType::UChar:
         case QMetaType::UShort:
         case QMetaType::ULong:
@@ -553,10 +553,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     }
 #ifndef QT_NO_GEOM_VARIANT
-    case QVariant::Size: {
+    case QMetaType::QSize: {
         QSize *s = static_cast<QSize *>(result);
         switch (d->type) {
-        case QVariant::SizeF:
+        case QMetaType::QSizeF:
             *s = v_cast<QSizeF>(d)->toSize();
             break;
         default:
@@ -565,10 +565,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     }
 
-    case QVariant::SizeF: {
+    case QMetaType::QSizeF: {
         QSizeF *s = static_cast<QSizeF *>(result);
         switch (d->type) {
-        case QVariant::Size:
+        case QMetaType::QSize:
             *s = QSizeF(*(v_cast<QSize>(d)));
             break;
         default:
@@ -577,10 +577,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     }
 
-    case QVariant::Line: {
+    case QMetaType::QLine: {
         QLine *s = static_cast<QLine *>(result);
         switch (d->type) {
-        case QVariant::LineF:
+        case QMetaType::QLineF:
             *s = v_cast<QLineF>(d)->toLine();
             break;
         default:
@@ -589,10 +589,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     }
 
-    case QVariant::LineF: {
+    case QMetaType::QLineF: {
         QLineF *s = static_cast<QLineF *>(result);
         switch (d->type) {
-        case QVariant::Line:
+        case QMetaType::QLine:
             *s = QLineF(*(v_cast<QLine>(d)));
             break;
         default:
@@ -601,27 +601,27 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     }
 #endif
-    case QVariant::StringList:
-        if (d->type == QVariant::List) {
+    case QMetaType::QStringList:
+        if (d->type == QMetaType::QVariantList) {
             QStringList *slst = static_cast<QStringList *>(result);
             const QVariantList *list = v_cast<QVariantList >(d);
             const int size = list->size();
             slst->reserve(size);
             for (int i = 0; i < size; ++i)
                 slst->append(list->at(i).toString());
-        } else if (d->type == QVariant::String) {
+        } else if (d->type == QMetaType::QString) {
             QStringList *slst = static_cast<QStringList *>(result);
             *slst = QStringList(*v_cast<QString>(d));
         } else {
             return false;
         }
         break;
-    case QVariant::Date: {
+    case QMetaType::QDate: {
         QDate *dt = static_cast<QDate *>(result);
-        if (d->type == QVariant::DateTime)
+        if (d->type == QMetaType::QDateTime)
             *dt = v_cast<QDateTime>(d)->date();
 #if QT_CONFIG(datestring)
-        else if (d->type == QVariant::String)
+        else if (d->type == QMetaType::QString)
             *dt = QDate::fromString(*v_cast<QString>(d), Qt::ISODate);
 #endif
         else
@@ -629,14 +629,14 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
 
         return dt->isValid();
     }
-    case QVariant::Time: {
+    case QMetaType::QTime: {
         QTime *t = static_cast<QTime *>(result);
         switch (d->type) {
-        case QVariant::DateTime:
+        case QMetaType::QDateTime:
             *t = v_cast<QDateTime>(d)->time();
             break;
 #if QT_CONFIG(datestring)
-        case QVariant::String:
+        case QMetaType::QString:
             *t = QTime::fromString(*v_cast<QString>(d), Qt::ISODate);
             break;
 #endif
@@ -645,11 +645,11 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         }
         return t->isValid();
     }
-    case QVariant::DateTime: {
+    case QMetaType::QDateTime: {
         QDateTime *dt = static_cast<QDateTime *>(result);
         switch (d->type) {
 #if QT_CONFIG(datestring)
-        case QVariant::String:
+        case QMetaType::QString:
             *dt = QDateTime::fromString(*v_cast<QString>(d), Qt::ISODate);
             break;
 #  ifndef QT_BOOTSTRAPPED
@@ -661,7 +661,7 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
             break;
 #  endif
 #endif
-        case QVariant::Date:
+        case QMetaType::QDate:
             *dt = QDateTime(*v_cast<QDate>(d));
             break;
         default:
@@ -669,13 +669,13 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         }
         return dt->isValid();
     }
-    case QVariant::ByteArray: {
+    case QMetaType::QByteArray: {
         QByteArray *ba = static_cast<QByteArray *>(result);
         switch (d->type) {
-        case QVariant::String:
+        case QMetaType::QString:
             *ba = v_cast<QString>(d)->toUtf8();
             break;
-        case QVariant::Double:
+        case QMetaType::Double:
             *ba = QByteArray::number(d->data.d, 'g', QLocale::FloatingPointShortest);
             break;
         case QMetaType::Float:
@@ -686,22 +686,22 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         case QMetaType::UChar:
             *ba = QByteArray(1, d->data.c);
             break;
-        case QVariant::Int:
-        case QVariant::LongLong:
+        case QMetaType::Int:
+        case QMetaType::LongLong:
         case QMetaType::Short:
         case QMetaType::Long:
             *ba = QByteArray::number(qMetaTypeNumber(d));
             break;
-        case QVariant::UInt:
-        case QVariant::ULongLong:
+        case QMetaType::UInt:
+        case QMetaType::ULongLong:
         case QMetaType::UShort:
         case QMetaType::ULong:
             *ba = QByteArray::number(qMetaTypeUNumber(d));
             break;
-        case QVariant::Bool:
+        case QMetaType::Bool:
             *ba = QByteArray(d->data.b ? "true" : "false");
             break;
-        case QVariant::Uuid:
+        case QMetaType::QUuid:
             *ba = v_cast<QUuid>(d)->toByteArray();
             break;
         case QMetaType::Nullptr:
@@ -741,16 +741,16 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
     case QMetaType::ULong:
         *static_cast<ulong *>(result) = ulong(qConvertToUnsignedNumber(d, ok));
         return *ok;
-    case QVariant::Int:
+    case QMetaType::Int:
         *static_cast<int *>(result) = int(qConvertToNumber(d, ok));
         return *ok;
-    case QVariant::UInt:
+    case QMetaType::UInt:
         *static_cast<uint *>(result) = uint(qConvertToUnsignedNumber(d, ok));
         return *ok;
-    case QVariant::LongLong:
+    case QMetaType::LongLong:
         *static_cast<qlonglong *>(result) = qConvertToNumber(d, ok);
         return *ok;
-    case QVariant::ULongLong: {
+    case QMetaType::ULongLong: {
         *static_cast<qulonglong *>(result) = qConvertToUnsignedNumber(d, ok);
         return *ok;
     }
@@ -763,21 +763,21 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         *static_cast<uchar *>(result) = qConvertToUnsignedNumber(d, ok);
         return *ok;
     }
-    case QVariant::Bool: {
+    case QMetaType::Bool: {
         bool *b = static_cast<bool *>(result);
         switch(d->type) {
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             *b = qt_convertToBool<QByteArray, const char*>(d);
             break;
-        case QVariant::String:
+        case QMetaType::QString:
             *b = qt_convertToBool<QString, QLatin1String>(d);
             break;
-        case QVariant::Char:
+        case QMetaType::QChar:
             *b = !v_cast<QChar>(d)->isNull();
             break;
-        case QVariant::Double:
-        case QVariant::Int:
-        case QVariant::LongLong:
+        case QMetaType::Double:
+        case QMetaType::Int:
+        case QMetaType::LongLong:
         case QMetaType::Char:
         case QMetaType::SChar:
         case QMetaType::Short:
@@ -785,8 +785,8 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         case QMetaType::Float:
             *b = qMetaTypeNumber(d) != Q_INT64_C(0);
             break;
-        case QVariant::UInt:
-        case QVariant::ULongLong:
+        case QMetaType::UInt:
+        case QMetaType::ULongLong:
         case QMetaType::UChar:
         case QMetaType::UShort:
         case QMetaType::ULong:
@@ -810,31 +810,31 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         }
         break;
     }
-    case QVariant::Double: {
+    case QMetaType::Double: {
         double *f = static_cast<double *>(result);
         switch (d->type) {
-        case QVariant::String:
+        case QMetaType::QString:
             *f = v_cast<QString>(d)->toDouble(ok);
             break;
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             *f = v_cast<QByteArray>(d)->toDouble(ok);
             break;
-        case QVariant::Bool:
+        case QMetaType::Bool:
             *f = double(d->data.b);
             break;
         case QMetaType::Float:
             *f = double(d->data.f);
             break;
-        case QVariant::LongLong:
-        case QVariant::Int:
+        case QMetaType::LongLong:
+        case QMetaType::Int:
         case QMetaType::Char:
         case QMetaType::SChar:
         case QMetaType::Short:
         case QMetaType::Long:
             *f = double(qMetaTypeNumber(d));
             break;
-        case QVariant::UInt:
-        case QVariant::ULongLong:
+        case QMetaType::UInt:
+        case QMetaType::ULongLong:
         case QMetaType::UChar:
         case QMetaType::UShort:
         case QMetaType::ULong:
@@ -861,28 +861,28 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
     case QMetaType::Float: {
         float *f = static_cast<float *>(result);
         switch (d->type) {
-        case QVariant::String:
+        case QMetaType::QString:
             *f = v_cast<QString>(d)->toFloat(ok);
             break;
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             *f = v_cast<QByteArray>(d)->toFloat(ok);
             break;
-        case QVariant::Bool:
+        case QMetaType::Bool:
             *f = float(d->data.b);
             break;
-        case QVariant::Double:
+        case QMetaType::Double:
             *f = float(d->data.d);
             break;
-        case QVariant::LongLong:
-        case QVariant::Int:
+        case QMetaType::LongLong:
+        case QMetaType::Int:
         case QMetaType::Char:
         case QMetaType::SChar:
         case QMetaType::Short:
         case QMetaType::Long:
             *f = float(qMetaTypeNumber(d));
             break;
-        case QVariant::UInt:
-        case QVariant::ULongLong:
+        case QMetaType::UInt:
+        case QMetaType::ULongLong:
         case QMetaType::UChar:
         case QMetaType::UShort:
         case QMetaType::ULong:
@@ -906,8 +906,8 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         }
         break;
     }
-    case QVariant::List:
-        if (d->type == QVariant::StringList) {
+    case QMetaType::QVariantList:
+        if (d->type == QMetaType::QStringList) {
             QVariantList *lst = static_cast<QVariantList *>(result);
             const QStringList *slist = v_cast<QStringList>(d);
             const int size = slist->size();
@@ -935,11 +935,11 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
             return false;
         }
         break;
-    case QVariant::Map:
+    case QMetaType::QVariantMap:
         if (qstrcmp(QMetaType::typeName(d->type), "QMap<QString, QVariant>") == 0) {
             *static_cast<QVariantMap *>(result) =
                 *static_cast<QMap<QString, QVariant> *>(d->data.shared->ptr);
-        } else if (d->type == QVariant::Hash) {
+        } else if (d->type == QMetaType::QVariantHash) {
             QVariantMap *map = static_cast<QVariantMap *>(result);
             const QVariantHash *hash = v_cast<QVariantHash>(d);
             const auto end = hash->end();
@@ -963,11 +963,11 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
             return false;
         }
         break;
-    case QVariant::Hash:
+    case QMetaType::QVariantHash:
         if (qstrcmp(QMetaType::typeName(d->type), "QHash<QString, QVariant>") == 0) {
             *static_cast<QVariantHash *>(result) =
                 *static_cast<QHash<QString, QVariant> *>(d->data.shared->ptr);
-        } else if (d->type == QVariant::Map) {
+        } else if (d->type == QMetaType::QVariantMap) {
             QVariantHash *hash = static_cast<QVariantHash *>(result);
             const QVariantMap *map = v_cast<QVariantMap>(d);
             const auto end = map->end();
@@ -992,26 +992,26 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         }
         break;
 #ifndef QT_NO_GEOM_VARIANT
-    case QVariant::Rect:
-        if (d->type == QVariant::RectF)
+    case QMetaType::QRect:
+        if (d->type == QMetaType::QRectF)
             *static_cast<QRect *>(result) = (v_cast<QRectF>(d))->toRect();
         else
             return false;
         break;
-    case QVariant::RectF:
-        if (d->type == QVariant::Rect)
+    case QMetaType::QRectF:
+        if (d->type == QMetaType::QRect)
             *static_cast<QRectF *>(result) = *v_cast<QRect>(d);
         else
             return false;
         break;
-    case QVariant::PointF:
-        if (d->type == QVariant::Point)
+    case QMetaType::QPointF:
+        if (d->type == QMetaType::QPoint)
             *static_cast<QPointF *>(result) = *v_cast<QPoint>(d);
         else
             return false;
         break;
-    case QVariant::Point:
-        if (d->type == QVariant::PointF)
+    case QMetaType::QPoint:
+        if (d->type == QMetaType::QPointF)
             *static_cast<QPoint *>(result) = (v_cast<QPointF>(d))->toPoint();
         else
             return false;
@@ -1022,12 +1022,12 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         return *ok;
     }
 #endif
-    case QVariant::Uuid:
+    case QMetaType::QUuid:
         switch (d->type) {
-        case QVariant::String:
+        case QMetaType::QString:
             *static_cast<QUuid *>(result) = QUuid(*v_cast<QString>(d));
             break;
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             *static_cast<QUuid *>(result) = QUuid(*v_cast<QByteArray>(d));
             break;
 #ifndef QT_BOOTSTRAPPED
@@ -1067,7 +1067,7 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         case QMetaType::Nullptr:
             *static_cast<QJsonValue *>(result) = QJsonValue(QJsonValue::Null);
             break;
-        case QVariant::Bool:
+        case QMetaType::Bool:
             *static_cast<QJsonValue *>(result) = QJsonValue(d->data.b);
             break;
         case QMetaType::Int:
@@ -1086,19 +1086,19 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
             *static_cast<QJsonValue *>(result) = QJsonValue(qConvertToRealNumber(d, ok));
             Q_ASSERT(ok);
             break;
-        case QVariant::String:
+        case QMetaType::QString:
             *static_cast<QJsonValue *>(result) = QJsonValue(*v_cast<QString>(d));
             break;
-        case QVariant::StringList:
+        case QMetaType::QStringList:
             *static_cast<QJsonValue *>(result) = QJsonValue(QJsonArray::fromStringList(*v_cast<QStringList>(d)));
             break;
-        case QVariant::List:
+        case QMetaType::QVariantList:
             *static_cast<QJsonValue *>(result) = QJsonValue(QJsonArray::fromVariantList(*v_cast<QVariantList>(d)));
             break;
-        case QVariant::Map:
+        case QMetaType::QVariantMap:
             *static_cast<QJsonValue *>(result) = QJsonValue(QJsonObject::fromVariantMap(*v_cast<QVariantMap>(d)));
             break;
-        case QVariant::Hash:
+        case QMetaType::QVariantHash:
             *static_cast<QJsonValue *>(result) = QJsonValue(QJsonObject::fromVariantHash(*v_cast<QVariantHash>(d)));
             break;
         case QMetaType::QJsonObject:
@@ -1128,10 +1128,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     case QMetaType::QJsonArray:
         switch (d->type) {
-        case QVariant::StringList:
+        case QMetaType::QStringList:
             *static_cast<QJsonArray *>(result) = QJsonArray::fromStringList(*v_cast<QStringList>(d));
             break;
-        case QVariant::List:
+        case QMetaType::QVariantList:
             *static_cast<QJsonArray *>(result) = QJsonArray::fromVariantList(*v_cast<QVariantList>(d));
             break;
         case QMetaType::QJsonValue:
@@ -1158,10 +1158,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     case QMetaType::QJsonObject:
         switch (d->type) {
-        case QVariant::Map:
+        case QMetaType::QVariantMap:
             *static_cast<QJsonObject *>(result) = QJsonObject::fromVariantMap(*v_cast<QVariantMap>(d));
             break;
-        case QVariant::Hash:
+        case QMetaType::QVariantHash:
             *static_cast<QJsonObject *>(result) = QJsonObject::fromVariantHash(*v_cast<QVariantHash>(d));
             break;
         case QMetaType::QJsonValue:
@@ -1197,7 +1197,7 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         case QMetaType::Nullptr:
             *static_cast<QCborValue *>(result) = QCborValue(QCborValue::Null);
             break;
-        case QVariant::Bool:
+        case QMetaType::Bool:
             *static_cast<QCborValue *>(result) = QCborValue(d->data.b);
             break;
         case QMetaType::Int:
@@ -1219,39 +1219,39 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
             *static_cast<QCborValue *>(result) = QCborValue(qConvertToRealNumber(d, ok));
             Q_ASSERT(ok);
             break;
-        case QVariant::String:
+        case QMetaType::QString:
             *static_cast<QCborValue *>(result) = *v_cast<QString>(d);
             break;
-        case QVariant::StringList:
+        case QMetaType::QStringList:
             *static_cast<QCborValue *>(result) = QCborArray::fromStringList(*v_cast<QStringList>(d));
             break;
-        case QVariant::ByteArray:
+        case QMetaType::QByteArray:
             *static_cast<QCborValue *>(result) = *v_cast<QByteArray>(d);
             break;
-        case QVariant::Date:
+        case QMetaType::QDate:
             *static_cast<QCborValue *>(result) = QCborValue(QDateTime(*v_cast<QDate>(d)));
             break;
-        case QVariant::DateTime:
+        case QMetaType::QDateTime:
             *static_cast<QCborValue *>(result) = QCborValue(*v_cast<QDateTime>(d));
             break;
-        case QVariant::Url:
+        case QMetaType::QUrl:
             *static_cast<QCborValue *>(result) = QCborValue(*v_cast<QUrl>(d));
             break;
 #if QT_CONFIG(regularexpression)
-        case QVariant::RegularExpression:
+        case QMetaType::QRegularExpression:
             *static_cast<QCborValue *>(result) = QCborValue(*v_cast<QRegularExpression>(d));
             break;
 #endif
-        case QVariant::Uuid:
+        case QMetaType::QUuid:
             *static_cast<QCborValue *>(result) = QCborValue(*v_cast<QUuid>(d));
             break;
-        case QVariant::List:
+        case QMetaType::QVariantList:
             *static_cast<QCborValue *>(result) = QCborArray::fromVariantList(*v_cast<QVariantList>(d));
             break;
-        case QVariant::Map:
+        case QMetaType::QVariantMap:
             *static_cast<QCborValue *>(result) = QCborMap::fromVariantMap(*v_cast<QVariantMap>(d));
             break;
-        case QVariant::Hash:
+        case QMetaType::QVariantHash:
             *static_cast<QCborValue *>(result) = QCborMap::fromVariantHash(*v_cast<QVariantHash>(d));
             break;
         case QMetaType::QJsonValue:
@@ -1287,10 +1287,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     case QMetaType::QCborArray:
         switch (d->type) {
-        case QVariant::StringList:
+        case QMetaType::QStringList:
             *static_cast<QCborArray *>(result) = QCborArray::fromStringList(*v_cast<QStringList>(d));
             break;
-        case QVariant::List:
+        case QMetaType::QVariantList:
             *static_cast<QCborArray *>(result) = QCborArray::fromVariantList(*v_cast<QVariantList>(d));
             break;
         case QMetaType::QCborValue:
@@ -1317,10 +1317,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
         break;
     case QMetaType::QCborMap:
         switch (d->type) {
-        case QVariant::Map:
+        case QMetaType::QVariantMap:
             *static_cast<QCborMap *>(result) = QCborMap::fromVariantMap(*v_cast<QVariantMap>(d));
             break;
-        case QVariant::Hash:
+        case QMetaType::QVariantHash:
             *static_cast<QCborMap *>(result) = QCborMap::fromVariantHash(*v_cast<QVariantHash>(d));
             break;
         case QMetaType::QCborValue:
@@ -1349,10 +1349,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
 
     default:
 #ifndef QT_NO_QOBJECT
-        if (d->type == QVariant::String || d->type == QVariant::ByteArray) {
+        if (d->type == QMetaType::QString || d->type == QMetaType::QByteArray) {
             QMetaEnum en = metaEnumFromType(t);
             if (en.isValid()) {
-                QByteArray keys = (d->type == QVariant::String) ? v_cast<QString>(d)->toUtf8() : *v_cast<QByteArray>(d);
+                QByteArray keys = (d->type == QMetaType::QString) ? v_cast<QString>(d)->toUtf8() : *v_cast<QByteArray>(d);
                 int value = en.keysToValue(keys.constData(), ok);
                 if (*ok) {
                     switch (QMetaType::sizeOf(t)) {
@@ -1457,7 +1457,7 @@ static void customConstruct(QVariant::Private *d, const void *copy)
     const uint size = type.sizeOf();
     if (!size) {
         qWarning("Trying to construct an instance of an invalid type, type id: %i", d->type);
-        d->type = QVariant::Invalid;
+        d->type = QMetaType::UnknownType;
         return;
     }
 
@@ -2438,43 +2438,43 @@ QVariant::Type QVariant::nameToType(const char *name)
 enum { MapFromThreeCount = 36 };
 static const ushort mapIdFromQt3ToCurrent[MapFromThreeCount] =
 {
-    QVariant::Invalid,
-    QVariant::Map,
-    QVariant::List,
-    QVariant::String,
-    QVariant::StringList,
-    QVariant::Font,
-    QVariant::Pixmap,
-    QVariant::Brush,
-    QVariant::Rect,
-    QVariant::Size,
-    QVariant::Color,
-    QVariant::Palette,
+    QMetaType::UnknownType,
+    QMetaType::QVariantMap,
+    QMetaType::QVariantList,
+    QMetaType::QString,
+    QMetaType::QStringList,
+    QMetaType::QFont,
+    QMetaType::QPixmap,
+    QMetaType::QBrush,
+    QMetaType::QRect,
+    QMetaType::QSize,
+    QMetaType::QColor,
+    QMetaType::QPalette,
     0, // ColorGroup
-    QVariant::Icon,
-    QVariant::Point,
-    QVariant::Image,
-    QVariant::Int,
-    QVariant::UInt,
-    QVariant::Bool,
-    QVariant::Double,
+    QMetaType::QIcon,
+    QMetaType::QPoint,
+    QMetaType::QImage,
+    QMetaType::Int,
+    QMetaType::UInt,
+    QMetaType::Bool,
+    QMetaType::Double,
     0, // Buggy ByteArray, QByteArray never had id == 20
-    QVariant::Polygon,
-    QVariant::Region,
-    QVariant::Bitmap,
-    QVariant::Cursor,
-    QVariant::SizePolicy,
-    QVariant::Date,
-    QVariant::Time,
-    QVariant::DateTime,
-    QVariant::ByteArray,
-    QVariant::BitArray,
-    QVariant::KeySequence,
-    QVariant::Pen,
-    QVariant::LongLong,
-    QVariant::ULongLong,
+    QMetaType::QPolygon,
+    QMetaType::QRegion,
+    QMetaType::QBitmap,
+    QMetaType::QCursor,
+    QMetaType::QSizePolicy,
+    QMetaType::QDate,
+    QMetaType::QTime,
+    QMetaType::QDateTime,
+    QMetaType::QByteArray,
+    QMetaType::QBitArray,
+    QMetaType::QKeySequence,
+    QMetaType::QPen,
+    QMetaType::LongLong,
+    QMetaType::ULongLong,
 #if QT_CONFIG(easingcurve)
-    QVariant::EasingCurve
+    QMetaType::QEasingCurve
 #endif
 };
 
@@ -2551,7 +2551,7 @@ void QVariant::load(QDataStream &s)
 */
 void QVariant::save(QDataStream &s) const
 {
-    quint32 typeId = type();
+    quint32 typeId = d.type >= QMetaType::User ? QMetaType::User : userType();
     bool fakeUserType = false;
     if (s.version() < QDataStream::Qt_4_0) {
         int i;
@@ -3294,80 +3294,80 @@ QVariantList QVariant::toList() const
 }
 
 
-static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] =
+static const quint32 qCanConvertMatrix[QMetaType::LastCoreType + 1] =
 {
 /*Invalid*/     0,
 
-/*Bool*/          1 << QVariant::Double     | 1 << QVariant::Int        | 1 << QVariant::UInt
-                | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong  | 1 << QVariant::ByteArray
-                | 1 << QVariant::String     | 1 << QVariant::Char,
+/*Bool*/          1 << QMetaType::Double     | 1 << QMetaType::Int        | 1 << QMetaType::UInt
+                | 1 << QMetaType::LongLong   | 1 << QMetaType::ULongLong  | 1 << QMetaType::QByteArray
+                | 1 << QMetaType::QString     | 1 << QMetaType::QChar,
 
-/*Int*/           1 << QVariant::UInt       | 1 << QVariant::String     | 1 << QVariant::Double
-                | 1 << QVariant::Bool       | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong
-                | 1 << QVariant::Char       | 1 << QVariant::ByteArray  | 1 << QVariant::Int,
+/*Int*/           1 << QMetaType::UInt       | 1 << QMetaType::QString     | 1 << QMetaType::Double
+                | 1 << QMetaType::Bool       | 1 << QMetaType::LongLong   | 1 << QMetaType::ULongLong
+                | 1 << QMetaType::QChar       | 1 << QMetaType::QByteArray  | 1 << QMetaType::Int,
 
-/*UInt*/          1 << QVariant::Int        | 1 << QVariant::String     | 1 << QVariant::Double
-                | 1 << QVariant::Bool       | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong
-                | 1 << QVariant::Char       | 1 << QVariant::ByteArray,
+/*UInt*/          1 << QMetaType::Int        | 1 << QMetaType::QString     | 1 << QMetaType::Double
+                | 1 << QMetaType::Bool       | 1 << QMetaType::LongLong   | 1 << QMetaType::ULongLong
+                | 1 << QMetaType::QChar       | 1 << QMetaType::QByteArray,
 
-/*LLong*/         1 << QVariant::Int        | 1 << QVariant::String     | 1 << QVariant::Double
-                | 1 << QVariant::Bool       | 1 << QVariant::UInt       | 1 << QVariant::ULongLong
-                | 1 << QVariant::Char       | 1 << QVariant::ByteArray,
+/*LLong*/         1 << QMetaType::Int        | 1 << QMetaType::QString     | 1 << QMetaType::Double
+                | 1 << QMetaType::Bool       | 1 << QMetaType::UInt       | 1 << QMetaType::ULongLong
+                | 1 << QMetaType::QChar       | 1 << QMetaType::QByteArray,
 
-/*ULlong*/        1 << QVariant::Int        | 1 << QVariant::String     | 1 << QVariant::Double
-                | 1 << QVariant::Bool       | 1 << QVariant::UInt       | 1 << QVariant::LongLong
-                | 1 << QVariant::Char       | 1 << QVariant::ByteArray,
+/*ULlong*/        1 << QMetaType::Int        | 1 << QMetaType::QString     | 1 << QMetaType::Double
+                | 1 << QMetaType::Bool       | 1 << QMetaType::UInt       | 1 << QMetaType::LongLong
+                | 1 << QMetaType::QChar       | 1 << QMetaType::QByteArray,
 
-/*double*/        1 << QVariant::Int        | 1 << QVariant::String     | 1 << QVariant::ULongLong
-                | 1 << QVariant::Bool       | 1 << QVariant::UInt       | 1 << QVariant::LongLong
-                | 1 << QVariant::ByteArray,
+/*double*/        1 << QMetaType::Int        | 1 << QMetaType::QString     | 1 << QMetaType::ULongLong
+                | 1 << QMetaType::Bool       | 1 << QMetaType::UInt       | 1 << QMetaType::LongLong
+                | 1 << QMetaType::QByteArray,
 
-/*QChar*/         1 << QVariant::Int        | 1 << QVariant::UInt       | 1 << QVariant::LongLong
-                | 1 << QVariant::ULongLong,
+/*QChar*/         1 << QMetaType::Int        | 1 << QMetaType::UInt       | 1 << QMetaType::LongLong
+                | 1 << QMetaType::ULongLong,
 
 /*QMap*/          0,
 
-/*QList*/         1 << QVariant::StringList,
+/*QList*/         1 << QMetaType::QStringList,
 
-/*QString*/       1 << QVariant::StringList | 1 << QVariant::ByteArray  | 1 << QVariant::Int
-                | 1 << QVariant::UInt       | 1 << QVariant::Bool       | 1 << QVariant::Double
-                | 1 << QVariant::Date       | 1 << QVariant::Time       | 1 << QVariant::DateTime
-                | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong  | 1 << QVariant::Char
-                | 1 << QVariant::Url        | 1 << QVariant::Uuid,
+/*QString*/       1 << QMetaType::QStringList | 1 << QMetaType::QByteArray  | 1 << QMetaType::Int
+                | 1 << QMetaType::UInt       | 1 << QMetaType::Bool       | 1 << QMetaType::Double
+                | 1 << QMetaType::QDate       | 1 << QMetaType::QTime       | 1 << QMetaType::QDateTime
+                | 1 << QMetaType::LongLong   | 1 << QMetaType::ULongLong  | 1 << QMetaType::QChar
+                | 1 << QMetaType::QUrl        | 1 << QMetaType::QUuid,
 
-/*QStringList*/   1 << QVariant::List       | 1 << QVariant::String,
+/*QStringList*/   1 << QMetaType::QVariantList       | 1 << QMetaType::QString,
 
-/*QByteArray*/    1 << QVariant::String     | 1 << QVariant::Int        | 1 << QVariant::UInt | 1 << QVariant::Bool
-                | 1 << QVariant::Double     | 1 << QVariant::LongLong   | 1 << QVariant::ULongLong
-                | 1 << QVariant::Uuid,
+/*QByteArray*/    1 << QMetaType::QString     | 1 << QMetaType::Int        | 1 << QMetaType::UInt | 1 << QMetaType::Bool
+                | 1 << QMetaType::Double     | 1 << QMetaType::LongLong   | 1 << QMetaType::ULongLong
+                | 1 << QMetaType::QUuid,
 
 /*QBitArray*/     0,
 
-/*QDate*/         1 << QVariant::String     | 1 << QVariant::DateTime,
+/*QDate*/         1 << QMetaType::QString     | 1 << QMetaType::QDateTime,
 
-/*QTime*/         1 << QVariant::String     | 1 << QVariant::DateTime,
+/*QTime*/         1 << QMetaType::QString     | 1 << QMetaType::QDateTime,
 
-/*QDateTime*/     1 << QVariant::String     | 1 << QVariant::Date,
+/*QDateTime*/     1 << QMetaType::QString     | 1 << QMetaType::QDate,
 
-/*QUrl*/          1 << QVariant::String,
+/*QUrl*/          1 << QMetaType::QString,
 
 /*QLocale*/       0,
 
-/*QRect*/         1 << QVariant::RectF,
+/*QRect*/         1 << QMetaType::QRectF,
 
-/*QRectF*/        1 << QVariant::Rect,
+/*QRectF*/        1 << QMetaType::QRect,
 
-/*QSize*/         1 << QVariant::SizeF,
+/*QSize*/         1 << QMetaType::QSizeF,
 
-/*QSizeF*/        1 << QVariant::Size,
+/*QSizeF*/        1 << QMetaType::QSize,
 
-/*QLine*/         1 << QVariant::LineF,
+/*QLine*/         1 << QMetaType::QLineF,
 
-/*QLineF*/        1 << QVariant::Line,
+/*QLineF*/        1 << QMetaType::QLine,
 
-/*QPoint*/        1 << QVariant::PointF,
+/*QPoint*/        1 << QMetaType::QPointF,
 
-/*QPointF*/       1 << QVariant::Point,
+/*QPointF*/       1 << QMetaType::QPoint,
 
 /*QRegExp*/       0,
 
@@ -3375,7 +3375,7 @@ static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] =
 
 /*QEasingCurve*/  0,
 
-/*QUuid*/         1 << QVariant::String     | 1 << QVariant::ByteArray,
+/*QUuid*/         1 << QMetaType::QString     | 1 << QMetaType::QByteArray,
 };
 static const size_t qCanConvertMatrixMaximumTargetType = 8 * sizeof(*qCanConvertMatrix);
 
@@ -3915,7 +3915,7 @@ static bool qIsNumericType(uint tp)
 
 static bool qIsFloatingPoint(uint tp)
 {
-    return tp == QVariant::Double || tp == QMetaType::Float;
+    return tp == QMetaType::Double || tp == QMetaType::Float;
 }
 
 static int normalizeLowerRanks(uint tp)
@@ -3927,13 +3927,13 @@ static int normalizeLowerRanks(uint tp)
             Q_UINT64_C(1) << QMetaType::UChar |
             Q_UINT64_C(1) << QMetaType::Short |
             Q_UINT64_C(1) << QMetaType::UShort;
-    return numericTypeBits & (Q_UINT64_C(1) << tp) ? QVariant::Int : tp;
+    return numericTypeBits & (Q_UINT64_C(1) << tp) ? uint(QMetaType::Int) : tp;
 }
 
 static int normalizeLong(uint tp)
 {
-    const uint IntType = sizeof(long) == sizeof(int) ? QVariant::Int : QVariant::LongLong;
-    const uint UIntType = sizeof(ulong) == sizeof(uint) ? QVariant::UInt : QVariant::ULongLong;
+    const uint IntType = sizeof(long) == sizeof(int) ? QMetaType::Int : QMetaType::LongLong;
+    const uint UIntType = sizeof(ulong) == sizeof(uint) ? QMetaType::UInt : QMetaType::ULongLong;
     return tp == QMetaType::Long ? IntType :
            tp == QMetaType::ULong ? UIntType : tp;
 }
@@ -3975,13 +3975,13 @@ static int numericTypePromotion(uint t1, uint t2)
     // if any of the two is ULongLong, then it wins (highest rank, unsigned)
     // otherwise, if one of the two is LongLong, then the other is either LongLong too or lower-ranked
     // otherwise, if one of the two is UInt, then the other is either UInt too or Int
-    if (t1 == QVariant::ULongLong || t2 == QVariant::ULongLong)
-        return QVariant::ULongLong;
-    if (t1 == QVariant::LongLong || t2 == QVariant::LongLong)
-        return QVariant::LongLong;
-    if (t1 == QVariant::UInt || t2 == QVariant::UInt)
-        return QVariant::UInt;
-    return QVariant::Int;
+    if (t1 == QMetaType::ULongLong || t2 == QMetaType::ULongLong)
+        return QMetaType::ULongLong;
+    if (t1 == QMetaType::LongLong || t2 == QMetaType::LongLong)
+        return QMetaType::LongLong;
+    if (t1 == QMetaType::UInt || t2 == QMetaType::UInt)
+        return QMetaType::UInt;
+    return QMetaType::Int;
 }
 
 static int integralCompare(uint promotedType, const QVariant::Private *d1, const QVariant::Private *d2)
@@ -3994,13 +3994,13 @@ static int integralCompare(uint promotedType, const QVariant::Private *d1, const
     qlonglong l2 = qConvertToNumber(d2, &ok);
     Q_ASSERT(ok);
 
-    if (promotedType == QVariant::Int)
+    if (promotedType == QMetaType::Int)
         return int(l1) < int(l2) ? -1 : int(l1) == int(l2) ? 0 : 1;
-    if (promotedType == QVariant::UInt)
+    if (promotedType == QMetaType::UInt)
         return uint(l1) < uint(l2) ? -1 : uint(l1) == uint(l2) ? 0 : 1;
-    if (promotedType == QVariant::LongLong)
+    if (promotedType == QMetaType::LongLong)
         return l1 < l2 ? -1 : l1 == l2 ? 0 : 1;
-    if (promotedType == QVariant::ULongLong)
+    if (promotedType == QMetaType::ULongLong)
         return qulonglong(l1) < qulonglong(l2) ? -1 : qulonglong(l1) == qulonglong(l2) ? 0 : 1;
 
     Q_UNREACHABLE();
diff --git a/src/corelib/kernel/qvariant_p.h b/src/corelib/kernel/qvariant_p.h
index b8b63b5e6f..94781a9957 100644
--- a/src/corelib/kernel/qvariant_p.h
+++ b/src/corelib/kernel/qvariant_p.h
@@ -362,7 +362,7 @@ class QVariantConstructor
         FilteredConstructor(const QVariantConstructor &tc)
         {
             // ignore types that lives outside of the current library
-            tc.m_x->type = QVariant::Invalid;
+            tc.m_x->type = QMetaType::UnknownType;
         }
     };
 public:
@@ -430,7 +430,7 @@ public:
     {}
     ~QVariantDestructor()
     {
-        m_d->type = QVariant::Invalid;
+        m_d->type = QMetaType::UnknownType;
         m_d->is_null = true;
         m_d->is_shared = false;
     }
diff --git a/src/corelib/serialization/qjsoncbor.cpp b/src/corelib/serialization/qjsoncbor.cpp
index 5097f4eb81..ee4dd90416 100644
--- a/src/corelib/serialization/qjsoncbor.cpp
+++ b/src/corelib/serialization/qjsoncbor.cpp
@@ -640,9 +640,9 @@ static void appendVariant(QCborContainerPrivate *d, const QVariant &variant)
     // Handle strings and byte arrays directly, to avoid creating a temporary
     // dummy container to hold their data.
     int type = variant.userType();
-    if (type == QVariant::String) {
+    if (type == QMetaType::QString) {
         d->append(variant.toString());
-    } else if (type == QVariant::ByteArray) {
+    } else if (type == QMetaType::QByteArray) {
         QByteArray ba = variant.toByteArray();
         d->appendByteData(ba.constData(), ba.size(), QCborValue::ByteArray);
     } else {
@@ -703,45 +703,45 @@ static void appendVariant(QCborContainerPrivate *d, const QVariant &variant)
 QCborValue QCborValue::fromVariant(const QVariant &variant)
 {
     switch (variant.userType()) {
-    case QVariant::Invalid:
+    case QMetaType::UnknownType:
         return {};
     case QMetaType::Nullptr:
         return nullptr;
-    case QVariant::Bool:
+    case QMetaType::Bool:
         return variant.toBool();
     case QMetaType::Short:
     case QMetaType::UShort:
-    case QVariant::Int:
-    case QVariant::LongLong:
-    case QVariant::ULongLong:
-    case QVariant::UInt:
+    case QMetaType::Int:
+    case QMetaType::LongLong:
+    case QMetaType::ULongLong:
+    case QMetaType::UInt:
         return variant.toLongLong();
     case QMetaType::Float:
-    case QVariant::Double:
+    case QMetaType::Double:
         return variant.toDouble();
-    case QVariant::String:
+    case QMetaType::QString:
         return variant.toString();
-    case QVariant::StringList:
+    case QMetaType::QStringList:
         return QCborArray::fromStringList(variant.toStringList());
-    case QVariant::ByteArray:
+    case QMetaType::QByteArray:
         return variant.toByteArray();
-    case QVariant::DateTime:
+    case QMetaType::QDateTime:
         return QCborValue(variant.toDateTime());
 #ifndef QT_BOOTSTRAPPED
-    case QVariant::Url:
+    case QMetaType::QUrl:
         return QCborValue(variant.toUrl());
 #endif
-    case QVariant::Uuid:
+    case QMetaType::QUuid:
         return QCborValue(variant.toUuid());
-    case QVariant::List:
+    case QMetaType::QVariantList:
         return QCborArray::fromVariantList(variant.toList());
-    case QVariant::Map:
+    case QMetaType::QVariantMap:
         return QCborMap::fromVariantMap(variant.toMap());
-    case QVariant::Hash:
+    case QMetaType::QVariantHash:
         return QCborMap::fromVariantHash(variant.toHash());
 #ifndef QT_BOOTSTRAPPED
 #if QT_CONFIG(regularexpression)
-    case QVariant::RegularExpression:
+    case QMetaType::QRegularExpression:
         return QCborValue(variant.toRegularExpression());
 #endif
     case QMetaType::QJsonValue:
diff --git a/src/corelib/serialization/qjsondocument.cpp b/src/corelib/serialization/qjsondocument.cpp
index fe0500bdef..0be0fc020d 100644
--- a/src/corelib/serialization/qjsondocument.cpp
+++ b/src/corelib/serialization/qjsondocument.cpp
@@ -405,17 +405,17 @@ QJsonDocument QJsonDocument::fromVariant(const QVariant &variant)
 {
     QJsonDocument doc;
 
-    switch (variant.type()) {
-    case QVariant::Map:
+    switch (variant.userType()) {
+    case QMetaType::QVariantMap:
         doc.setObject(QJsonObject::fromVariantMap(variant.toMap()));
         break;
-    case QVariant::Hash:
+    case QMetaType::QVariantHash:
         doc.setObject(QJsonObject::fromVariantHash(variant.toHash()));
         break;
-    case QVariant::List:
+    case QMetaType::QVariantList:
         doc.setArray(QJsonArray::fromVariantList(variant.toList()));
         break;
-    case QVariant::StringList:
+    case QMetaType::QStringList:
         doc.d = qt_make_unique<QJsonDocumentPrivate>();
         doc.d->value = QCborArray::fromStringList(variant.toStringList());
         break;
diff --git a/src/corelib/serialization/qjsonvalue.cpp b/src/corelib/serialization/qjsonvalue.cpp
index 7b6728d525..caf81c79ef 100644
--- a/src/corelib/serialization/qjsonvalue.cpp
+++ b/src/corelib/serialization/qjsonvalue.cpp
@@ -447,29 +447,29 @@ QJsonValue QJsonValue::fromVariant(const QVariant &variant)
     switch (variant.userType()) {
     case QMetaType::Nullptr:
         return QJsonValue(Null);
-    case QVariant::Bool:
+    case QMetaType::Bool:
         return QJsonValue(variant.toBool());
-    case QVariant::Int:
+    case QMetaType::Int:
     case QMetaType::Float:
-    case QVariant::Double:
-    case QVariant::LongLong:
-    case QVariant::ULongLong:
-    case QVariant::UInt:
+    case QMetaType::Double:
+    case QMetaType::LongLong:
+    case QMetaType::ULongLong:
+    case QMetaType::UInt:
         return QJsonValue(variant.toDouble());
-    case QVariant::String:
+    case QMetaType::QString:
         return QJsonValue(variant.toString());
-    case QVariant::StringList:
+    case QMetaType::QStringList:
         return QJsonValue(QJsonArray::fromStringList(variant.toStringList()));
-    case QVariant::List:
+    case QMetaType::QVariantList:
         return QJsonValue(QJsonArray::fromVariantList(variant.toList()));
-    case QVariant::Map:
+    case QMetaType::QVariantMap:
         return QJsonValue(QJsonObject::fromVariantMap(variant.toMap()));
-    case QVariant::Hash:
+    case QMetaType::QVariantHash:
         return QJsonValue(QJsonObject::fromVariantHash(variant.toHash()));
 #ifndef QT_BOOTSTRAPPED
-    case QVariant::Url:
+    case QMetaType::QUrl:
         return QJsonValue(variant.toUrl().toString(QUrl::FullyEncoded));
-    case QVariant::Uuid:
+    case QMetaType::QUuid:
         return variant.toUuid().toString(QUuid::WithoutBraces);
     case QMetaType::QJsonValue:
         return variant.toJsonValue();
diff --git a/src/corelib/text/qlocale.cpp b/src/corelib/text/qlocale.cpp
index 93a8abb1ce..fb45b82967 100644
--- a/src/corelib/text/qlocale.cpp
+++ b/src/corelib/text/qlocale.cpp
@@ -2430,7 +2430,7 @@ QTime QLocale::toTime(const QString &string, const QString &format, QCalendar ca
 {
     QTime time;
 #if QT_CONFIG(datetimeparser)
-    QDateTimeParser dt(QVariant::Time, QDateTimeParser::FromString, cal);
+    QDateTimeParser dt(QMetaType::QTime, QDateTimeParser::FromString, cal);
     dt.setDefaultLocale(*this);
     if (dt.parseFormat(format))
         dt.fromString(string, nullptr, &time);
@@ -2469,7 +2469,7 @@ QDate QLocale::toDate(const QString &string, const QString &format, QCalendar ca
 {
     QDate date;
 #if QT_CONFIG(datetimeparser)
-    QDateTimeParser dt(QVariant::Date, QDateTimeParser::FromString, cal);
+    QDateTimeParser dt(QMetaType::QDate, QDateTimeParser::FromString, cal);
     dt.setDefaultLocale(*this);
     if (dt.parseFormat(format))
         dt.fromString(string, &date, nullptr);
@@ -2510,7 +2510,7 @@ QDateTime QLocale::toDateTime(const QString &string, const QString &format, QCal
     QTime time;
     QDate date;
 
-    QDateTimeParser dt(QVariant::DateTime, QDateTimeParser::FromString, cal);
+    QDateTimeParser dt(QMetaType::QDateTime, QDateTimeParser::FromString, cal);
     dt.setDefaultLocale(*this);
     if (dt.parseFormat(format) && dt.fromString(string, &date, &time))
         return QDateTime(date, time);
diff --git a/src/corelib/text/qlocale_unix.cpp b/src/corelib/text/qlocale_unix.cpp
index 5e1e47eae7..207331b8ac 100644
--- a/src/corelib/text/qlocale_unix.cpp
+++ b/src/corelib/text/qlocale_unix.cpp
@@ -234,16 +234,16 @@ QVariant QSystemLocale::query(QueryType type, QVariant in) const
     case CurrencySymbol:
         return lc_monetary.currencySymbol(QLocale::CurrencySymbolFormat(in.toUInt()));
     case CurrencyToString: {
-        switch (in.type()) {
-        case QVariant::Int:
+        switch (in.userType()) {
+        case QMetaType::Int:
             return lc_monetary.toCurrencyString(in.toInt());
-        case QVariant::UInt:
+        case QMetaType::UInt:
             return lc_monetary.toCurrencyString(in.toUInt());
-        case QVariant::Double:
+        case QMetaType::Double:
             return lc_monetary.toCurrencyString(in.toDouble());
-        case QVariant::LongLong:
+        case QMetaType::LongLong:
             return lc_monetary.toCurrencyString(in.toLongLong());
-        case QVariant::ULongLong:
+        case QMetaType::ULongLong:
             return lc_monetary.toCurrencyString(in.toULongLong());
         default:
             break;
diff --git a/src/corelib/time/qdatetime.cpp b/src/corelib/time/qdatetime.cpp
index 67d37f19d8..80751e60a0 100644
--- a/src/corelib/time/qdatetime.cpp
+++ b/src/corelib/time/qdatetime.cpp
@@ -1791,7 +1791,7 @@ QDate QDate::fromString(const QString &string, const QString &format, QCalendar
 {
     QDate date;
 #if QT_CONFIG(datetimeparser)
-    QDateTimeParser dt(QVariant::Date, QDateTimeParser::FromString, cal);
+    QDateTimeParser dt(QMetaType::QDate, QDateTimeParser::FromString, cal);
     // dt.setDefaultLocale(QLocale::c()); ### Qt 6
     if (dt.parseFormat(format))
         dt.fromString(string, &date, nullptr);
@@ -2537,7 +2537,7 @@ QTime QTime::fromString(const QString &string, const QString &format)
 {
     QTime time;
 #if QT_CONFIG(datetimeparser)
-    QDateTimeParser dt(QVariant::Time, QDateTimeParser::FromString, QCalendar());
+    QDateTimeParser dt(QMetaType::QTime, QDateTimeParser::FromString, QCalendar());
     // dt.setDefaultLocale(QLocale::c()); ### Qt 6
     if (dt.parseFormat(format))
         dt.fromString(string, nullptr, &time);
@@ -5482,7 +5482,7 @@ QDateTime QDateTime::fromString(const QString &string, const QString &format, QC
     QTime time;
     QDate date;
 
-    QDateTimeParser dt(QVariant::DateTime, QDateTimeParser::FromString, cal);
+    QDateTimeParser dt(QMetaType::QDateTime, QDateTimeParser::FromString, cal);
     // dt.setDefaultLocale(QLocale::c()); ### Qt 6
     if (dt.parseFormat(format) && dt.fromString(string, &date, &time))
         return QDateTime(date, time);
diff --git a/src/corelib/time/qdatetimeparser.cpp b/src/corelib/time/qdatetimeparser.cpp
index 31d8e6cc20..70460ae632 100644
--- a/src/corelib/time/qdatetimeparser.cpp
+++ b/src/corelib/time/qdatetimeparser.cpp
@@ -425,7 +425,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
             switch (sect) {
             case 'H':
             case 'h':
-                if (parserType != QVariant::Date) {
+                if (parserType != QMetaType::QDate) {
                     const Section hour = (sect == 'h') ? Hour12Section : Hour24Section;
                     const SectionNode sn = { hour, i - add, countRepeat(newFormat, i, 2), 0 };
                     newSectionNodes.append(sn);
@@ -436,7 +436,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
                 }
                 break;
             case 'm':
-                if (parserType != QVariant::Date) {
+                if (parserType != QMetaType::QDate) {
                     const SectionNode sn = { MinuteSection, i - add, countRepeat(newFormat, i, 2), 0 };
                     newSectionNodes.append(sn);
                     appendSeparator(&newSeparators, newFormat, index, i - index, lastQuote);
@@ -446,7 +446,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
                 }
                 break;
             case 's':
-                if (parserType != QVariant::Date) {
+                if (parserType != QMetaType::QDate) {
                     const SectionNode sn = { SecondSection, i - add, countRepeat(newFormat, i, 2), 0 };
                     newSectionNodes.append(sn);
                     appendSeparator(&newSeparators, newFormat, index, i - index, lastQuote);
@@ -457,7 +457,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
                 break;
 
             case 'z':
-                if (parserType != QVariant::Date) {
+                if (parserType != QMetaType::QDate) {
                     const SectionNode sn = { MSecSection, i - add, countRepeat(newFormat, i, 3) < 3 ? 1 : 3, 0 };
                     newSectionNodes.append(sn);
                     appendSeparator(&newSeparators, newFormat, index, i - index, lastQuote);
@@ -468,7 +468,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
                 break;
             case 'A':
             case 'a':
-                if (parserType != QVariant::Date) {
+                if (parserType != QMetaType::QDate) {
                     const bool cap = (sect == 'A');
                     const SectionNode sn = { AmPmSection, i - add, (cap ? 1 : 0), 0 };
                     newSectionNodes.append(sn);
@@ -482,7 +482,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
                 }
                 break;
             case 'y':
-                if (parserType != QVariant::Time) {
+                if (parserType != QMetaType::QTime) {
                     const int repeat = countRepeat(newFormat, i, 4);
                     if (repeat >= 2) {
                         const SectionNode sn = { repeat == 4 ? YearSection : YearSection2Digits,
@@ -496,7 +496,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
                 }
                 break;
             case 'M':
-                if (parserType != QVariant::Time) {
+                if (parserType != QMetaType::QTime) {
                     const SectionNode sn = { MonthSection, i - add, countRepeat(newFormat, i, 4), 0 };
                     newSectionNodes.append(sn);
                     newSeparators.append(unquote(newFormat.midRef(index, i - index)));
@@ -506,7 +506,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
                 }
                 break;
             case 'd':
-                if (parserType != QVariant::Time) {
+                if (parserType != QMetaType::QTime) {
                     const int repeat = countRepeat(newFormat, i, 4);
                     const Section sectionType = (repeat == 4 ? DayOfWeekSectionLong
                         : (repeat == 3 ? DayOfWeekSectionShort : DaySection));
@@ -519,7 +519,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat)
                 }
                 break;
             case 't':
-                if (parserType != QVariant::Time) {
+                if (parserType != QMetaType::QTime) {
                     const SectionNode sn = { TimeZoneSection, i - add, countRepeat(newFormat, i, 4), 0 };
                     newSectionNodes.append(sn);
                     appendSeparator(&newSeparators, newFormat, index, i - index, lastQuote);
@@ -1252,7 +1252,7 @@ QDateTimeParser::scanString(const QDateTime &defaultValue,
         return StateNode();
     }
 
-    if (parserType != QVariant::Time) {
+    if (parserType != QMetaType::QTime) {
         if (year % 100 != year2digits && (isSet & YearSection2Digits)) {
             if (!(isSet & YearSection)) {
                 year = (year / 100) * 100;
@@ -1322,7 +1322,7 @@ QDateTimeParser::scanString(const QDateTime &defaultValue,
         }
     }
 
-    if (parserType != QVariant::Date) {
+    if (parserType != QMetaType::QDate) {
         if (isSet & Hour12Section) {
             const bool hasHour = isSet & Hour24Section;
             if (ampm == -1) {
@@ -1360,7 +1360,7 @@ QDateTimeParser::scanString(const QDateTime &defaultValue,
 
     // If hour wasn't specified, check the default we're using exists on the
     // given date (which might be a spring-forward, skipping an hour).
-    if (parserType == QVariant::DateTime && !(isSet & HourSectionMask) && !when.isValid()) {
+    if (parserType == QMetaType::QDateTime && !(isSet & HourSectionMask) && !when.isValid()) {
         qint64 msecs = when.toMSecsSinceEpoch();
         // Fortunately, that gets a useful answer, even though when is invalid ...
         const QDateTime replace =
diff --git a/src/corelib/time/qdatetimeparser_p.h b/src/corelib/time/qdatetimeparser_p.h
index ec4e4e4df2..5c612ef6a4 100644
--- a/src/corelib/time/qdatetimeparser_p.h
+++ b/src/corelib/time/qdatetimeparser_p.h
@@ -83,7 +83,7 @@ public:
         FromString,
         DateTimeEdit
     };
-    QDateTimeParser(QVariant::Type t, Context ctx, const QCalendar &cal = QCalendar())
+    QDateTimeParser(QMetaType::Type t, Context ctx, const QCalendar &cal = QCalendar())
         : currentSectionIndex(-1), cachedDay(-1), parserType(t),
         fixday(false), spec(Qt::LocalTime), context(ctx), calendar(cal)
     {
@@ -295,7 +295,7 @@ protected: // for the benefit of QDateTimeEditPrivate
     QStringList separators;
     QString displayFormat;
     QLocale defaultLocale;
-    QVariant::Type parserType;
+    QMetaType::Type parserType;
     bool fixday;
     Qt::TimeSpec spec; // spec if used by QDateTimeEdit
     Context context;