Merge remote-tracking branch 'origin/dev' into wip/cmake

 Conflicts:
        src/corelib/Qt5CoreConfigExtras.cmake.in
        src/corelib/Qt5CoreMacros.cmake
        src/dbus/Qt5DBusConfigExtras.cmake.in
        src/widgets/Qt5WidgetsConfigExtras.cmake.in

Change-Id: Ib782f3b177c38b2cce83beebe15be9c0baa578f7

9 files changed, 318 insertions, 299 deletions

diff --git a/src/corelib/kernel/qabstracteventdispatcher.cpp b/src/corelib/kernel/qabstracteventdispatcher.cpp
index 7215b3f2bd..685a0c595a 100644
--- a/src/corelib/kernel/qabstracteventdispatcher.cpp
+++ b/src/corelib/kernel/qabstracteventdispatcher.cpp
@@ -160,7 +160,7 @@ QAbstractEventDispatcher::~QAbstractEventDispatcher()
 
 /*!
     Returns a pointer to the event dispatcher object for the specified
-    \a thread. If \a thread is zero, the current thread is used. If no
+    \a thread. If \a thread is \nullptr, the current thread is used. If no
     event dispatcher exists for the specified thread, this function
     returns \nullptr.
 
diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp
index 3883613d49..f4d0a88529 100644
--- a/src/corelib/kernel/qmetaobject.cpp
+++ b/src/corelib/kernel/qmetaobject.cpp
@@ -603,7 +603,7 @@ static bool methodMatch(const QMetaObject *m, int handle,
 * \internal
 * helper function for indexOf{Method,Slot,Signal}, returns the relative index of the method within
 * the baseObject
-* \a MethodType might be MethodSignal or MethodSlot, or 0 to match everything.
+* \a MethodType might be MethodSignal or MethodSlot, or \nullptr to match everything.
 */
 template<int MethodType>
 static inline int indexOfMethodRelative(const QMetaObject **baseObject,
@@ -737,7 +737,7 @@ int QMetaObject::indexOfSignal(const char *signal) const
     \internal
     Same as QMetaObject::indexOfSignal, but the result is the local offset to the base object.
 
-    \a baseObject will be adjusted to the enclosing QMetaObject, or 0 if the signal is not found
+    \a baseObject will be adjusted to the enclosing QMetaObject, or \nullptr if the signal is not found
 */
 int QMetaObjectPrivate::indexOfSignalRelative(const QMetaObject **baseObject,
                                               const QByteArray &name, int argc,
@@ -2988,7 +2988,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;
     }
@@ -3106,7 +3106,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
@@ -3183,9 +3183,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));
@@ -3193,13 +3193,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;
@@ -3579,6 +3579,21 @@ bool QMetaProperty::isFinal() const
 }
 
 /*!
+  \since 5.15
+  Returns \c true if the property is required; otherwise returns \c false.
+
+  A property is final if the \c{Q_PROPERTY()}'s \c REQUIRED attribute
+  is set.
+*/
+bool QMetaProperty::isRequired() const
+{
+    if (!mobj)
+        return false;
+    int flags = mobj->d.data[handle + 2];
+    return flags & Required;
+}
+
+/*!
     \obsolete
 
     Returns \c true if the property is editable for the given \a object;
diff --git a/src/corelib/kernel/qmetaobject.h b/src/corelib/kernel/qmetaobject.h
index 31fecd0b07..d0c4b489a6 100644
--- a/src/corelib/kernel/qmetaobject.h
+++ b/src/corelib/kernel/qmetaobject.h
@@ -263,6 +263,7 @@ public:
     bool isUser(const QObject *obj = nullptr) const;
     bool isConstant() const;
     bool isFinal() const;
+    bool isRequired() const;
 
     bool isFlagType() const;
     bool isEnumType() const;
diff --git a/src/corelib/kernel/qmetaobject_p.h b/src/corelib/kernel/qmetaobject_p.h
index 56e3d6cb44..277109dac4 100644
--- a/src/corelib/kernel/qmetaobject_p.h
+++ b/src/corelib/kernel/qmetaobject_p.h
@@ -85,7 +85,8 @@ enum PropertyFlags  {
     User = 0x00100000,
     ResolveUser = 0x00200000,
     Notify = 0x00400000,
-    Revisioned = 0x00800000
+    Revisioned = 0x00800000,
+    Required = 0x01000000,
 };
 
 enum MethodFlags  {
diff --git a/src/corelib/kernel/qmetatype.cpp b/src/corelib/kernel/qmetatype.cpp
index 79d6d0aa93..e498772e32 100644
--- a/src/corelib/kernel/qmetatype.cpp
+++ b/src/corelib/kernel/qmetatype.cpp
@@ -254,6 +254,7 @@ struct DefinedTypesFilter {
     \value QPolygon QPolygon
     \value QPolygonF QPolygonF
     \value QColor QColor
+    \value QColorSpace QColorSpace
     \value QSizeF QSizeF
     \value QRectF QRectF
     \value QLine QLine
@@ -458,7 +459,7 @@ struct DefinedTypesFilter {
     \deprecated
 
     Constructs a value of the given type which is a copy of \a copy.
-    The default value for \a copy is 0.
+    The default value for \a copy is \nullptr.
 
     Deprecated, use the static function QMetaType::create(int type,
     const void *copy) instead.
diff --git a/src/corelib/kernel/qmetatype.h b/src/corelib/kernel/qmetatype.h
index 7628f5f6b3..927bfb7667 100644
--- a/src/corelib/kernel/qmetatype.h
+++ b/src/corelib/kernel/qmetatype.h
@@ -182,6 +182,7 @@ inline Q_DECL_CONSTEXPR int qMetaTypeId();
     F(QVector4D, 84, QVector4D) \
     F(QQuaternion, 85, QQuaternion) \
     F(QPolygonF, 86, QPolygonF) \
+    F(QColorSpace, 87, QColorSpace) \
 
 
 #define QT_FOR_EACH_STATIC_WIDGETS_CLASS(F)\
@@ -440,7 +441,7 @@ public:
         FirstCoreType = Bool,
         LastCoreType = QCborMap,
         FirstGuiType = QFont,
-        LastGuiType = QPolygonF,
+        LastGuiType = QColorSpace,
         FirstWidgetsType = QSizePolicy,
         LastWidgetsType = QSizePolicy,
         HighestInternalId = LastWidgetsType,
@@ -475,12 +476,12 @@ public:
         QIcon = 69, QImage = 70, QPolygon = 71, QRegion = 72, QBitmap = 73,
         QCursor = 74, QKeySequence = 75, QPen = 76, QTextLength = 77, QTextFormat = 78,
         QMatrix = 79, QTransform = 80, QMatrix4x4 = 81, QVector2D = 82,
-        QVector3D = 83, QVector4D = 84, QQuaternion = 85, QPolygonF = 86,
+        QVector3D = 83, QVector4D = 84, QQuaternion = 85, QPolygonF = 86, QColorSpace = 87,
 
         // Widget types
         QSizePolicy = 121,
         LastCoreType = QCborMap,
-        LastGuiType = QPolygonF,
+        LastGuiType = QColorSpace,
         User = 1024
     };
 #endif
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 d1bd2d308f..236ed96d78 100644
--- a/src/corelib/kernel/qvariant.cpp
+++ b/src/corelib/kernel/qvariant.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2019 The Qt Company Ltd.
+** Copyright (C) 2020 The Qt Company Ltd.
 ** Copyright (C) 2018 Intel Corporation.
 ** Copyright (C) 2015 Olivier Goffart <ogoffart@woboq.com>
 ** Contact: https://www.qt.io/licensing/
@@ -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,45 +2438,45 @@ 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,
+    QMetaType::QPolygon,
+    QMetaType::QRegion,
+    QMetaType::QBitmap,
+    QMetaType::QCursor,
+    QMetaType::QSizePolicy,
+    QMetaType::QDate,
+    QMetaType::QTime,
+    QMetaType::QDateTime,
+    QMetaType::QByteArray,
+    QMetaType::QBitArray,
 #if QT_CONFIG(shortcut)
-    QVariant::KeySequence,
+    QMetaType::QKeySequence,
 #endif
-    QVariant::Pen,
-    QVariant::LongLong,
-    QVariant::ULongLong,
+    QMetaType::QPen,
+    QMetaType::LongLong,
+    QMetaType::ULongLong,
 #if QT_CONFIG(easingcurve)
-    QVariant::EasingCurve
+    QMetaType::QEasingCurve
 #endif
 };
 
@@ -2553,7 +2553,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;
@@ -3300,80 +3300,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,
 
@@ -3381,7 +3381,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);
 
@@ -3862,7 +3862,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)
@@ -3874,13 +3874,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;
 }
@@ -3922,13 +3922,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)
@@ -3941,13 +3941,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;
     }