15 files changed, 263 insertions, 486 deletions

diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index b6b4da3885..e5098b8415 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -1265,7 +1265,11 @@ bool QCoreApplication::closingDown()
     \l{QCoreApplication::sendPostedEvents()}{sendPostedEvents()} from
     within that local loop.
 
-    Calling this function processes events only for the calling thread.
+    Calling this function processes events only for the calling thread,
+    and returns after all available events have been processed. Available
+    events are events queued before the function call. This means that
+    events that are posted while the function runs will be queued until
+    a later round of event processing.
 
     \threadsafe
 
@@ -1282,7 +1286,7 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags)
 /*!
     \overload processEvents()
 
-    Processes pending events for the calling thread for \a maxtime
+    Processes pending events for the calling thread for \a ms
     milliseconds or until there are no more events to process,
     whichever is shorter.
 
@@ -1291,11 +1295,14 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags)
 
     Calling this function processes events only for the calling thread.
 
+    \note Unlike the \l{QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags)}{processEvents()}
+    overload, this function also processes events that are posted while the function runs.
+
     \threadsafe
 
     \sa exec(), QTimer, QEventLoop::processEvents()
 */
-void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int maxtime)
+void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int ms)
 {
     // ### Qt 6: consider splitting this method into a public and a private
     //           one, so that a user-invoked processEvents can be detected
@@ -1306,7 +1313,7 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int m
     QElapsedTimer start;
     start.start();
     while (data->eventDispatcher.load()->processEvents(flags & ~QEventLoop::WaitForMoreEvents)) {
-        if (start.elapsed() > maxtime)
+        if (start.elapsed() > ms)
             break;
     }
 }
diff --git a/src/corelib/kernel/qeventdispatcher_glib.cpp b/src/corelib/kernel/qeventdispatcher_glib.cpp
index 45c6e29e4b..34c2dde6a8 100644
--- a/src/corelib/kernel/qeventdispatcher_glib.cpp
+++ b/src/corelib/kernel/qeventdispatcher_glib.cpp
@@ -86,9 +86,10 @@ static gboolean socketNotifierSourceCheck(GSource *source)
                      p->pollfd.fd, t[int(p->socketNotifier->type())]);
             // ### note, modifies src->pollfds!
             p->socketNotifier->setEnabled(false);
+            i--;
+        } else {
+            pending = pending || ((p->pollfd.revents & p->pollfd.events) != 0);
         }
-
-        pending = ((p->pollfd.revents & p->pollfd.events) != 0);
     }
 
     return pending;
diff --git a/src/corelib/kernel/qjni_p.h b/src/corelib/kernel/qjni_p.h
index 52abd51dc1..ec8525e6e1 100644
--- a/src/corelib/kernel/qjni_p.h
+++ b/src/corelib/kernel/qjni_p.h
@@ -76,7 +76,7 @@ public:
 
 private:
     friend class QAndroidJniEnvironment;
-    Q_DISABLE_COPY(QJNIEnvironmentPrivate)
+    Q_DISABLE_COPY_MOVE(QJNIEnvironmentPrivate)
     JNIEnv *jniEnv;
 };
 
diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp
index 5de2717078..27153e0c4d 100644
--- a/src/corelib/kernel/qmetaobject.cpp
+++ b/src/corelib/kernel/qmetaobject.cpp
@@ -2257,9 +2257,9 @@ bool QMetaMethod::invoke(QObject *object,
         return false;
 
     // check connection type
-    QThread *currentThread = QThread::currentThread();
-    QThread *objectThread = object->thread();
     if (connectionType == Qt::AutoConnection) {
+        QThread *currentThread = QThread::currentThread();
+        QThread *objectThread = object->thread();
         connectionType = currentThread == objectThread
                          ? Qt::DirectConnection
                          : Qt::QueuedConnection;
@@ -2342,6 +2342,8 @@ bool QMetaMethod::invoke(QObject *object,
                                                         0, -1, nargs, types, args));
     } else { // blocking queued connection
 #if QT_CONFIG(thread)
+        QThread *currentThread = QThread::currentThread();
+        QThread *objectThread = object->thread();
         if (currentThread == objectThread) {
             qWarning("QMetaMethod::invoke: Dead lock detected in "
                         "BlockingQueuedConnection: Receiver is %s(%p)",
diff --git a/src/corelib/kernel/qmetaobjectbuilder_p.h b/src/corelib/kernel/qmetaobjectbuilder_p.h
index 115ec835aa..6100835bad 100644
--- a/src/corelib/kernel/qmetaobjectbuilder_p.h
+++ b/src/corelib/kernel/qmetaobjectbuilder_p.h
@@ -184,7 +184,7 @@ public:
 #endif
 
 private:
-    Q_DISABLE_COPY(QMetaObjectBuilder)
+    Q_DISABLE_COPY_MOVE(QMetaObjectBuilder)
 
     QMetaObjectBuilderPrivate *d;
 
diff --git a/src/corelib/kernel/qmetatype.cpp b/src/corelib/kernel/qmetatype.cpp
index 632b86959d..b9e35e28e4 100644
--- a/src/corelib/kernel/qmetatype.cpp
+++ b/src/corelib/kernel/qmetatype.cpp
@@ -290,6 +290,10 @@ struct DefinedTypesFilter {
     \value QJsonObject QJsonObject
     \value QJsonArray QJsonArray
     \value QJsonDocument QJsonDocument
+    \value QCborValue QCborValue
+    \value QCborArray QCborArray
+    \value QCborMap QCborMap
+    \value QCborSimpleType QCborSimpleType
     \value QModelIndex QModelIndex
     \value QPersistentModelIndex QPersistentModelIndex (since 5.5)
     \value QUuid QUuid
@@ -373,6 +377,13 @@ struct DefinedTypesFilter {
 */
 
 /*!
+    \fn int QMetaType::id() const
+    \since 5.13
+
+    Returns id type hold by this QMetatype instance.
+*/
+
+/*!
     \fn bool QMetaType::sizeOf() const
     \since 5.0
 
@@ -1374,236 +1385,197 @@ int QMetaType::type(const QT_PREPEND_NAMESPACE(QByteArray) &typeName)
 }
 
 #ifndef QT_NO_DATASTREAM
-/*!
-    Writes the object pointed to by \a data with the ID \a type to
-    the given \a stream. Returns \c true if the object is saved
-    successfully; otherwise returns \c false.
 
-    The type must have been registered with qRegisterMetaType() and
-    qRegisterMetaTypeStreamOperators() beforehand.
+namespace
+{
 
-    Normally, you should not need to call this function directly.
-    Instead, use QVariant's \c operator<<(), which relies on save()
-    to stream custom types.
+template<typename T>
+class HasStreamOperator
+{
+    struct Yes { char unused[1]; };
+    struct No { char unused[2]; };
+    Q_STATIC_ASSERT(sizeof(Yes) != sizeof(No));
+
+    template<class C> static decltype(std::declval<QDataStream&>().operator>>(std::declval<C&>()), Yes()) load(int);
+    template<class C> static decltype(operator>>(std::declval<QDataStream&>(), std::declval<C&>()), Yes()) load(int);
+    template<class C> static No load(...);
+    template<class C> static decltype(operator<<(std::declval<QDataStream&>(), std::declval<const C&>()), Yes()) saveFunction(int);
+    template<class C> static decltype(std::declval<QDataStream&>().operator<<(std::declval<const C&>()), Yes()) saveMethod(int);
+    template<class C> static No saveMethod(...);
+    template<class C> static No saveFunction(...);
+    static constexpr bool LoadValue = QtMetaTypePrivate::TypeDefinition<T>::IsAvailable && (sizeof(load<T>(0)) == sizeof(Yes));
+    static constexpr bool SaveValue = QtMetaTypePrivate::TypeDefinition<T>::IsAvailable &&
+        ((sizeof(saveMethod<T>(0)) == sizeof(Yes)) || (sizeof(saveFunction<T>(0)) == sizeof(Yes)));
+public:
+    static constexpr bool Value = LoadValue && SaveValue;
+};
 
-    \sa load(), qRegisterMetaTypeStreamOperators()
-*/
-bool QMetaType::save(QDataStream &stream, int type, const void *data)
+// Quick sanity checks
+Q_STATIC_ASSERT(HasStreamOperator<NS(QJsonDocument)>::Value);
+Q_STATIC_ASSERT(!HasStreamOperator<void*>::Value);
+Q_STATIC_ASSERT(HasStreamOperator<qint8>::Value);
+
+template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted && HasStreamOperator<T>::Value>
+struct FilteredOperatorSwitch
+{
+    static bool load(QDataStream &stream, T *data, int)
+    {
+        stream >> *data;
+        return true;
+    }
+    static bool save(QDataStream &stream, const T *data, int)
+    {
+        stream << *data;
+        return true;
+    }
+};
+template<typename T>
+struct FilteredOperatorSwitch<T, /* IsAcceptedType = */ false>
 {
-    if (!data || !isRegistered(type))
+    static const QMetaTypeInterface* getMetaTypeInterface(int type)
+    {
+        if (QModulesPrivate::QTypeModuleInfo<T>::IsGui && qMetaTypeGuiHelper)
+            return &qMetaTypeGuiHelper[type - QMetaType::FirstGuiType];
+        else if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget && qMetaTypeWidgetsHelper)
+            return &qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType];
+        return nullptr;
+    }
+    static bool save(QDataStream &stream, const T *data, int type)
+    {
+        if (auto interface = getMetaTypeInterface(type)) {
+            interface->saveOp(stream, data);
+            return true;
+        }
         return false;
-
-    switch(type) {
-    case QMetaType::UnknownType:
-    case QMetaType::Void:
-    case QMetaType::VoidStar:
-    case QMetaType::QObjectStar:
-#if QT_CONFIG(itemmodel)
-    case QMetaType::QModelIndex:
-    case QMetaType::QPersistentModelIndex:
-#endif
-    case QMetaType::QJsonValue:
-    case QMetaType::QJsonObject:
-    case QMetaType::QJsonArray:
-    case QMetaType::QJsonDocument:
-    case QMetaType::QCborValue:
-    case QMetaType::QCborArray:
-    case QMetaType::QCborMap:
+    }
+    static bool load(QDataStream &stream, T *data, int type)
+    {
+        if (auto interface = getMetaTypeInterface(type)) {
+            interface->loadOp(stream, data);
+            return true;
+        }
         return false;
-    case QMetaType::Nullptr:
-        stream << *static_cast<const std::nullptr_t *>(data);
-        return true;
-    case QMetaType::Long:
-        stream << qlonglong(*static_cast<const long *>(data));
-        break;
-    case QMetaType::Int:
-        stream << *static_cast<const int *>(data);
-        break;
-    case QMetaType::Short:
-        stream << *static_cast<const short *>(data);
-        break;
-    case QMetaType::Char:
+    }
+};
+
+class SaveOperatorSwitch
+{
+public:
+    QDataStream &stream;
+    int m_type;
+
+    template<typename T>
+    bool delegate(const T *data)
+    {
+        return FilteredOperatorSwitch<T>::save(stream, data, m_type);
+    }
+    bool delegate(const char *data)
+    {
         // force a char to be signed
-        stream << *static_cast<const signed char *>(data);
-        break;
-    case QMetaType::ULong:
-        stream << qulonglong(*static_cast<const ulong *>(data));
-        break;
-    case QMetaType::UInt:
-        stream << *static_cast<const uint *>(data);
-        break;
-    case QMetaType::LongLong:
-        stream << *static_cast<const qlonglong *>(data);
-        break;
-    case QMetaType::ULongLong:
-        stream << *static_cast<const qulonglong *>(data);
-        break;
-    case QMetaType::UShort:
-        stream << *static_cast<const ushort *>(data);
-        break;
-    case QMetaType::SChar:
-        stream << *static_cast<const signed char *>(data);
-        break;
-    case QMetaType::UChar:
-        stream << *static_cast<const uchar *>(data);
-        break;
-    case QMetaType::Bool:
-        stream << qint8(*static_cast<const bool *>(data));
-        break;
-    case QMetaType::Float:
-        stream << *static_cast<const float *>(data);
-        break;
-    case QMetaType::Double:
-        stream << *static_cast<const double *>(data);
-        break;
-    case QMetaType::QChar:
-        stream << *static_cast<const NS(QChar) *>(data);
-        break;
-#ifndef QT_BOOTSTRAPPED
-    case QMetaType::QVariantMap:
-        stream << *static_cast<const NS(QVariantMap)*>(data);
-        break;
-    case QMetaType::QVariantHash:
-        stream << *static_cast<const NS(QVariantHash)*>(data);
-        break;
-    case QMetaType::QVariantList:
-        stream << *static_cast<const NS(QVariantList)*>(data);
-        break;
-    case QMetaType::QVariant:
-        stream << *static_cast<const NS(QVariant)*>(data);
-        break;
-    case QMetaType::QByteArrayList:
-        stream << *static_cast<const NS(QByteArrayList)*>(data);
-        break;
-#endif
-    case QMetaType::QByteArray:
-        stream << *static_cast<const NS(QByteArray)*>(data);
-        break;
-    case QMetaType::QString:
-        stream << *static_cast<const NS(QString)*>(data);
-        break;
-    case QMetaType::QStringList:
-        stream << *static_cast<const NS(QStringList)*>(data);
-        break;
-#ifndef QT_BOOTSTRAPPED
-    case QMetaType::QBitArray:
-        stream << *static_cast<const NS(QBitArray)*>(data);
-        break;
-#endif
-    case QMetaType::QDate:
-        stream << *static_cast<const NS(QDate)*>(data);
-        break;
-    case QMetaType::QTime:
-        stream << *static_cast<const NS(QTime)*>(data);
-        break;
-    case QMetaType::QDateTime:
-        stream << *static_cast<const NS(QDateTime)*>(data);
-        break;
-#ifndef QT_BOOTSTRAPPED
-    case QMetaType::QUrl:
-        stream << *static_cast<const NS(QUrl)*>(data);
-        break;
-#endif
-    case QMetaType::QLocale:
-        stream << *static_cast<const NS(QLocale)*>(data);
-        break;
-#ifndef QT_NO_GEOM_VARIANT
-    case QMetaType::QRect:
-        stream << *static_cast<const NS(QRect)*>(data);
-        break;
-    case QMetaType::QRectF:
-        stream << *static_cast<const NS(QRectF)*>(data);
-        break;
-    case QMetaType::QSize:
-        stream << *static_cast<const NS(QSize)*>(data);
-        break;
-    case QMetaType::QSizeF:
-        stream << *static_cast<const NS(QSizeF)*>(data);
-        break;
-    case QMetaType::QLine:
-        stream << *static_cast<const NS(QLine)*>(data);
-        break;
-    case QMetaType::QLineF:
-        stream << *static_cast<const NS(QLineF)*>(data);
-        break;
-    case QMetaType::QPoint:
-        stream << *static_cast<const NS(QPoint)*>(data);
-        break;
-    case QMetaType::QPointF:
-        stream << *static_cast<const NS(QPointF)*>(data);
-        break;
-#endif
-#ifndef QT_NO_REGEXP
-    case QMetaType::QRegExp:
-        stream << *static_cast<const NS(QRegExp)*>(data);
-        break;
-#endif
-#if QT_CONFIG(regularexpression)
-    case QMetaType::QRegularExpression:
-        stream << *static_cast<const NS(QRegularExpression)*>(data);
-        break;
-#endif // QT_CONFIG(regularexpression)
-#ifndef QT_BOOTSTRAPPED
-    case QMetaType::QEasingCurve:
-        stream << *static_cast<const NS(QEasingCurve)*>(data);
-        break;
-    case QMetaType::QCborSimpleType:
-        stream << *static_cast<const quint8 *>(data);
-        break;
-#endif // QT_BOOTSTRAPPED
-    case QMetaType::QFont:
-    case QMetaType::QPixmap:
-    case QMetaType::QBrush:
-    case QMetaType::QColor:
-    case QMetaType::QPalette:
-    case QMetaType::QImage:
-    case QMetaType::QPolygon:
-    case QMetaType::QPolygonF:
-    case QMetaType::QRegion:
-    case QMetaType::QBitmap:
-    case QMetaType::QCursor:
-    case QMetaType::QKeySequence:
-    case QMetaType::QPen:
-    case QMetaType::QTextLength:
-    case QMetaType::QTextFormat:
-    case QMetaType::QMatrix:
-    case QMetaType::QTransform:
-    case QMetaType::QMatrix4x4:
-    case QMetaType::QVector2D:
-    case QMetaType::QVector3D:
-    case QMetaType::QVector4D:
-    case QMetaType::QQuaternion:
-    case QMetaType::QIcon:
-        if (!qMetaTypeGuiHelper)
-            return false;
-        qMetaTypeGuiHelper[type - FirstGuiType].saveOp(stream, data);
-        break;
-    case QMetaType::QSizePolicy:
-        if (!qMetaTypeWidgetsHelper)
-            return false;
-        qMetaTypeWidgetsHelper[type - FirstWidgetsType].saveOp(stream, data);
-        break;
-    case QMetaType::QUuid:
-        stream << *static_cast<const NS(QUuid)*>(data);
-        break;
-    default: {
+        stream << qint8(*data);
+        return true;
+    }
+    bool delegate(const long *data)
+    {
+        stream << qlonglong(*data);
+        return true;
+    }
+    bool delegate(const unsigned long *data)
+    {
+        stream << qulonglong(*data);
+        return true;
+    }
+    bool delegate(const QMetaTypeSwitcher::NotBuiltinType *data)
+    {
         const QVector<QCustomTypeInfo> * const ct = customTypes();
         if (!ct)
             return false;
-
-        SaveOperator saveOp = 0;
+        QMetaType::SaveOperator saveOp = nullptr;
         {
             QReadLocker locker(customTypesLock());
-            saveOp = ct->at(type - User).saveOp;
+            saveOp = ct->at(m_type - QMetaType::User).saveOp;
         }
-
         if (!saveOp)
             return false;
         saveOp(stream, data);
-        break; }
+        return true;
     }
+    bool delegate(const void*) { return false; }
+    bool delegate(const QMetaTypeSwitcher::UnknownType*) { return false; }
+};
+class LoadOperatorSwitch
+{
+public:
+    QDataStream &stream;
+    int m_type;
 
-    return true;
+    template<typename T>
+    bool delegate(const T *data)
+    {
+        return FilteredOperatorSwitch<T>::load(stream, const_cast<T*>(data), m_type);
+    }
+    bool delegate(const char *data)
+    {
+        // force a char to be signed
+        qint8 c;
+        stream >> c;
+        *const_cast<char*>(data) = c;
+        return true;
+    }
+    bool delegate(const long *data)
+    {
+        qlonglong l;
+        stream >> l;
+        *const_cast<long*>(data) = l;
+        return true;
+    }
+    bool delegate(const unsigned long *data)
+    {
+        qlonglong l;
+        stream >> l;
+        *const_cast<unsigned long*>(data) = l;
+        return true;
+    }
+    bool delegate(const QMetaTypeSwitcher::NotBuiltinType *data)
+    {
+        const QVector<QCustomTypeInfo> * const ct = customTypes();
+        if (!ct)
+            return false;
+        QMetaType::LoadOperator loadOp = nullptr;
+        {
+            QReadLocker locker(customTypesLock());
+            loadOp = ct->at(m_type - QMetaType::User).loadOp;
+        }
+        if (!loadOp)
+            return false;
+        loadOp(stream, const_cast<QMetaTypeSwitcher::NotBuiltinType*>(data));
+        return true;
+    }
+    bool delegate(const void*) { return false; }
+    bool delegate(const QMetaTypeSwitcher::UnknownType*) { return false; }
+};
+}  // namespace
+
+/*!
+    Writes the object pointed to by \a data with the ID \a type to
+    the given \a stream. Returns \c true if the object is saved
+    successfully; otherwise returns \c false.
+
+    The type must have been registered with qRegisterMetaType() and
+    qRegisterMetaTypeStreamOperators() beforehand.
+
+    Normally, you should not need to call this function directly.
+    Instead, use QVariant's \c operator<<(), which relies on save()
+    to stream custom types.
+
+    \sa load(), qRegisterMetaTypeStreamOperators()
+*/
+bool QMetaType::save(QDataStream &stream, int type, const void *data)
+{
+    if (!data)
+        return false;
+    SaveOperatorSwitch saveOp{stream, type};
+    return QMetaTypeSwitcher::switcher<bool>(saveOp, type, data);
 }
 
 /*!
@@ -1622,225 +1594,10 @@ bool QMetaType::save(QDataStream &stream, int type, const void *data)
 */
 bool QMetaType::load(QDataStream &stream, int type, void *data)
 {
-    if (!data || !isRegistered(type))
-        return false;
-
-    switch(type) {
-    case QMetaType::UnknownType:
-    case QMetaType::Void:
-    case QMetaType::VoidStar:
-    case QMetaType::QObjectStar:
-#if QT_CONFIG(itemmodel)
-    case QMetaType::QModelIndex:
-    case QMetaType::QPersistentModelIndex:
-#endif
-    case QMetaType::QJsonValue:
-    case QMetaType::QJsonObject:
-    case QMetaType::QJsonArray:
-    case QMetaType::QJsonDocument:
-    case QMetaType::QCborValue:
-    case QMetaType::QCborArray:
-    case QMetaType::QCborMap:
+   if (!data)
         return false;
-    case QMetaType::Nullptr:
-        stream >> *static_cast<std::nullptr_t *>(data);
-        return true;
-    case QMetaType::Long: {
-        qlonglong l;
-        stream >> l;
-        *static_cast<long *>(data) = long(l);
-        break; }
-    case QMetaType::Int:
-        stream >> *static_cast<int *>(data);
-        break;
-    case QMetaType::Short:
-        stream >> *static_cast<short *>(data);
-        break;
-    case QMetaType::Char:
-        // force a char to be signed
-        stream >> *static_cast<signed char *>(data);
-        break;
-    case QMetaType::ULong: {
-        qulonglong ul;
-        stream >> ul;
-        *static_cast<ulong *>(data) = ulong(ul);
-        break; }
-    case QMetaType::UInt:
-        stream >> *static_cast<uint *>(data);
-        break;
-    case QMetaType::LongLong:
-        stream >> *static_cast<qlonglong *>(data);
-        break;
-    case QMetaType::ULongLong:
-        stream >> *static_cast<qulonglong *>(data);
-        break;
-    case QMetaType::UShort:
-        stream >> *static_cast<ushort *>(data);
-        break;
-    case QMetaType::SChar:
-        stream >> *static_cast<signed char *>(data);
-        break;
-    case QMetaType::UChar:
-        stream >> *static_cast<uchar *>(data);
-        break;
-    case QMetaType::Bool: {
-        qint8 b;
-        stream >> b;
-        *static_cast<bool *>(data) = b;
-        break; }
-    case QMetaType::Float:
-        stream >> *static_cast<float *>(data);
-        break;
-    case QMetaType::Double:
-        stream >> *static_cast<double *>(data);
-        break;
-    case QMetaType::QChar:
-        stream >> *static_cast< NS(QChar)*>(data);
-        break;
-#ifndef QT_BOOTSTRAPPED
-    case QMetaType::QVariantMap:
-        stream >> *static_cast< NS(QVariantMap)*>(data);
-        break;
-    case QMetaType::QVariantHash:
-        stream >> *static_cast< NS(QVariantHash)*>(data);
-        break;
-    case QMetaType::QVariantList:
-        stream >> *static_cast< NS(QVariantList)*>(data);
-        break;
-    case QMetaType::QVariant:
-        stream >> *static_cast< NS(QVariant)*>(data);
-        break;
-    case QMetaType::QByteArrayList:
-        stream >> *static_cast< NS(QByteArrayList)*>(data);
-        break;
-#endif
-    case QMetaType::QByteArray:
-        stream >> *static_cast< NS(QByteArray)*>(data);
-        break;
-    case QMetaType::QString:
-        stream >> *static_cast< NS(QString)*>(data);
-        break;
-    case QMetaType::QStringList:
-        stream >> *static_cast< NS(QStringList)*>(data);
-        break;
-#ifndef QT_BOOTSTRAPPED
-    case QMetaType::QBitArray:
-        stream >> *static_cast< NS(QBitArray)*>(data);
-        break;
-#endif
-    case QMetaType::QDate:
-        stream >> *static_cast< NS(QDate)*>(data);
-        break;
-    case QMetaType::QTime:
-        stream >> *static_cast< NS(QTime)*>(data);
-        break;
-    case QMetaType::QDateTime:
-        stream >> *static_cast< NS(QDateTime)*>(data);
-        break;
-#ifndef QT_BOOTSTRAPPED
-    case QMetaType::QUrl:
-        stream >> *static_cast< NS(QUrl)*>(data);
-        break;
-#endif
-    case QMetaType::QLocale:
-        stream >> *static_cast< NS(QLocale)*>(data);
-        break;
-#ifndef QT_NO_GEOM_VARIANT
-    case QMetaType::QRect:
-        stream >> *static_cast< NS(QRect)*>(data);
-        break;
-    case QMetaType::QRectF:
-        stream >> *static_cast< NS(QRectF)*>(data);
-        break;
-    case QMetaType::QSize:
-        stream >> *static_cast< NS(QSize)*>(data);
-        break;
-    case QMetaType::QSizeF:
-        stream >> *static_cast< NS(QSizeF)*>(data);
-        break;
-    case QMetaType::QLine:
-        stream >> *static_cast< NS(QLine)*>(data);
-        break;
-    case QMetaType::QLineF:
-        stream >> *static_cast< NS(QLineF)*>(data);
-        break;
-    case QMetaType::QPoint:
-        stream >> *static_cast< NS(QPoint)*>(data);
-        break;
-    case QMetaType::QPointF:
-        stream >> *static_cast< NS(QPointF)*>(data);
-        break;
-#endif
-#ifndef QT_NO_REGEXP
-    case QMetaType::QRegExp:
-        stream >> *static_cast< NS(QRegExp)*>(data);
-        break;
-#endif
-#if QT_CONFIG(regularexpression)
-    case QMetaType::QRegularExpression:
-        stream >> *static_cast< NS(QRegularExpression)*>(data);
-        break;
-#endif // QT_CONFIG(regularexpression)
-#ifndef QT_BOOTSTRAPPED
-    case QMetaType::QEasingCurve:
-        stream >> *static_cast< NS(QEasingCurve)*>(data);
-        break;
-    case QMetaType::QCborSimpleType:
-        stream >> *static_cast<quint8 *>(data);
-        break;
-#endif // QT_BOOTSTRAPPED
-    case QMetaType::QFont:
-    case QMetaType::QPixmap:
-    case QMetaType::QBrush:
-    case QMetaType::QColor:
-    case QMetaType::QPalette:
-    case QMetaType::QImage:
-    case QMetaType::QPolygon:
-    case QMetaType::QPolygonF:
-    case QMetaType::QRegion:
-    case QMetaType::QBitmap:
-    case QMetaType::QCursor:
-    case QMetaType::QKeySequence:
-    case QMetaType::QPen:
-    case QMetaType::QTextLength:
-    case QMetaType::QTextFormat:
-    case QMetaType::QMatrix:
-    case QMetaType::QTransform:
-    case QMetaType::QMatrix4x4:
-    case QMetaType::QVector2D:
-    case QMetaType::QVector3D:
-    case QMetaType::QVector4D:
-    case QMetaType::QQuaternion:
-    case QMetaType::QIcon:
-        if (!qMetaTypeGuiHelper)
-            return false;
-        qMetaTypeGuiHelper[type - FirstGuiType].loadOp(stream, data);
-        break;
-    case QMetaType::QSizePolicy:
-        if (!qMetaTypeWidgetsHelper)
-            return false;
-        qMetaTypeWidgetsHelper[type - FirstWidgetsType].loadOp(stream, data);
-        break;
-    case QMetaType::QUuid:
-        stream >> *static_cast< NS(QUuid)*>(data);
-        break;
-    default: {
-        const QVector<QCustomTypeInfo> * const ct = customTypes();
-        if (!ct)
-            return false;
-
-        LoadOperator loadOp = 0;
-        {
-            QReadLocker locker(customTypesLock());
-            loadOp = ct->at(type - User).loadOp;
-        }
-
-        if (!loadOp)
-            return false;
-        loadOp(stream, data);
-        break; }
-    }
-    return true;
+    LoadOperatorSwitch loadOp{stream, type};
+    return QMetaTypeSwitcher::switcher<bool>(loadOp, type, data);
 }
 #endif // QT_NO_DATASTREAM
 
diff --git a/src/corelib/kernel/qmetatype.h b/src/corelib/kernel/qmetatype.h
index ed7feee775..a47fbfe28d 100644
--- a/src/corelib/kernel/qmetatype.h
+++ b/src/corelib/kernel/qmetatype.h
@@ -570,6 +570,7 @@ public:
 
     inline bool isValid() const;
     inline bool isRegistered() const;
+    inline int id() const;
     inline int sizeOf() const;
     inline TypeFlags flags() const;
     inline const QMetaObject *metaObject() const;
@@ -1976,7 +1977,9 @@ QT_FOR_EACH_STATIC_WIDGETS_CLASS(QT_FORWARD_DECLARE_STATIC_TYPES_ITER)
 typedef QList<QVariant> QVariantList;
 typedef QMap<QString, QVariant> QVariantMap;
 typedef QHash<QString, QVariant> QVariantHash;
-#ifndef Q_CLANG_QDOC
+#ifdef Q_CLANG_QDOC
+class QByteArrayList;
+#else
 typedef QList<QByteArray> QByteArrayList;
 #endif
 
@@ -2221,6 +2224,11 @@ inline bool QMetaType::isRegistered() const
     return isValid();
 }
 
+inline int QMetaType::id() const
+{
+    return m_typeId;
+}
+
 inline void *QMetaType::create(const void *copy) const
 {
     // ### TODO Qt6 remove the extension
diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp
index b5d97c5538..600a801fe0 100644
--- a/src/corelib/kernel/qobject.cpp
+++ b/src/corelib/kernel/qobject.cpp
@@ -1824,12 +1824,15 @@ void QObject::killTimer(int id)
 /*!
     \fn template<typename T> QList<T> QObject::findChildren(const QRegExp &regExp, Qt::FindChildOptions options) const
     \overload findChildren()
+    \obsolete
 
     Returns the children of this object that can be cast to type T
     and that have names matching the regular expression \a regExp,
     or an empty list if there are no such objects.
     The search is performed recursively, unless \a options specifies the
     option FindDirectChildrenOnly.
+
+    Use the findChildren overload taking a QRegularExpression instead.
 */
 
 /*!
@@ -2148,7 +2151,8 @@ void QObject::removeEventFilter(QObject *obj)
     \fn void QObject::destroyed(QObject *obj)
 
     This signal is emitted immediately before the object \a obj is
-    destroyed, and can not be blocked.
+    destroyed, after any instances of QPointer have been notified,
+    and can not be blocked.
 
     All the objects's children are destroyed immediately after this
     signal is emitted.
@@ -3673,10 +3677,12 @@ void QMetaObject::activate(QObject *sender, int signalOffset, int local_signal_i
         return;
     }
 
-    void *empty_argv[] = { 0 };
+    void *empty_argv[] = { nullptr };
+    if (!argv)
+        argv = empty_argv;
+
     if (qt_signal_spy_callback_set.signal_begin_callback != 0) {
-        qt_signal_spy_callback_set.signal_begin_callback(sender, signal_index,
-                                                         argv ? argv : empty_argv);
+        qt_signal_spy_callback_set.signal_begin_callback(sender, signal_index, argv);
     }
     Q_TRACE(QMetaObject_activate_begin_signal, sender, signal_index);
 
@@ -3739,7 +3745,7 @@ void QMetaObject::activate(QObject *sender, int signalOffset, int local_signal_i
             // put into the event queue
             if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread)
                 || (c->connectionType == Qt::QueuedConnection)) {
-                queued_activate(sender, signal_index, c, argv ? argv : empty_argv, locker);
+                queued_activate(sender, signal_index, c, argv, locker);
                 continue;
 #if QT_CONFIG(thread)
             } else if (c->connectionType == Qt::BlockingQueuedConnection) {
@@ -3751,8 +3757,8 @@ void QMetaObject::activate(QObject *sender, int signalOffset, int local_signal_i
                 }
                 QSemaphore semaphore;
                 QMetaCallEvent *ev = c->isSlotObject ?
-                    new QMetaCallEvent(c->slotObj, sender, signal_index, 0, 0, argv ? argv : empty_argv, &semaphore) :
-                    new QMetaCallEvent(c->method_offset, c->method_relative, c->callFunction, sender, signal_index, 0, 0, argv ? argv : empty_argv, &semaphore);
+                    new QMetaCallEvent(c->slotObj, sender, signal_index, 0, 0, argv, &semaphore) :
+                    new QMetaCallEvent(c->method_offset, c->method_relative, c->callFunction, sender, signal_index, 0, 0, argv, &semaphore);
                 QCoreApplication::postEvent(receiver, ev);
                 locker.unlock();
                 semaphore.acquire();
@@ -3771,7 +3777,7 @@ void QMetaObject::activate(QObject *sender, int signalOffset, int local_signal_i
                 QScopedPointer<QtPrivate::QSlotObjectBase, QSlotObjectBaseDeleter> obj(c->slotObj);
                 locker.unlock();
                 Q_TRACE(QMetaObject_activate_begin_slot_functor, obj.data());
-                obj->call(receiver, argv ? argv : empty_argv);
+                obj->call(receiver, argv);
                 Q_TRACE(QMetaObject_activate_end_slot_functor, obj.data());
 
                 // Make sure the slot object gets destroyed before the mutex is locked again, as the
@@ -3787,10 +3793,10 @@ void QMetaObject::activate(QObject *sender, int signalOffset, int local_signal_i
                 const auto callFunction = c->callFunction;
                 locker.unlock();
                 if (qt_signal_spy_callback_set.slot_begin_callback != 0)
-                    qt_signal_spy_callback_set.slot_begin_callback(receiver, methodIndex, argv ? argv : empty_argv);
+                    qt_signal_spy_callback_set.slot_begin_callback(receiver, methodIndex, argv);
                 Q_TRACE(QMetaObject_activate_begin_slot, receiver, methodIndex);
 
-                callFunction(receiver, QMetaObject::InvokeMetaMethod, method_relative, argv ? argv : empty_argv);
+                callFunction(receiver, QMetaObject::InvokeMetaMethod, method_relative, argv);
 
                 Q_TRACE(QMetaObject_activate_end_slot, receiver, methodIndex);
                 if (qt_signal_spy_callback_set.slot_end_callback != 0)
@@ -3801,13 +3807,11 @@ void QMetaObject::activate(QObject *sender, int signalOffset, int local_signal_i
                 locker.unlock();
 
                 if (qt_signal_spy_callback_set.slot_begin_callback != 0) {
-                    qt_signal_spy_callback_set.slot_begin_callback(receiver,
-                                                                method,
-                                                                argv ? argv : empty_argv);
+                    qt_signal_spy_callback_set.slot_begin_callback(receiver, method, argv);
                 }
                 Q_TRACE(QMetaObject_activate_begin_slot, receiver, method);
 
-                metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv ? argv : empty_argv);
+                metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv);
 
                 Q_TRACE(QMetaObject_activate_end_slot, receiver, method);
                 if (qt_signal_spy_callback_set.slot_end_callback != 0)
diff --git a/src/corelib/kernel/qobject.h b/src/corelib/kernel/qobject.h
index aac9bcdee9..52c1b8e555 100644
--- a/src/corelib/kernel/qobject.h
+++ b/src/corelib/kernel/qobject.h
@@ -176,7 +176,9 @@ public:
     }
 
 #ifndef QT_NO_REGEXP
+#if QT_DEPRECATED_SINCE(5, 13)
     template<typename T>
+    QT_DEPRECATED_X("Use findChildren(const RegularExpression &, ...) instead.")
     inline QList<T> findChildren(const QRegExp &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
     {
         typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType;
@@ -186,6 +188,7 @@ public:
         return list;
     }
 #endif
+#endif
 
 #if QT_CONFIG(regularexpression)
     template<typename T>
@@ -517,7 +520,10 @@ inline T qobject_cast(const QObject *object)
 template <class T> inline const char * qobject_interface_iid()
 { return nullptr; }
 
-#if !defined(Q_MOC_RUN) && !defined(Q_CLANG_QDOC)
+
+#if defined(Q_CLANG_QDOC)
+#  define Q_DECLARE_INTERFACE(IFace, IId)
+#elif !defined(Q_MOC_RUN)
 #  define Q_DECLARE_INTERFACE(IFace, IId) \
     template <> inline const char *qobject_interface_iid<IFace *>() \
     { return IId; } \
diff --git a/src/corelib/kernel/qobject_p.h b/src/corelib/kernel/qobject_p.h
index 5dfef786ec..a762e6f529 100644
--- a/src/corelib/kernel/qobject_p.h
+++ b/src/corelib/kernel/qobject_p.h
@@ -407,7 +407,7 @@ private:
 
 class QBoolBlocker
 {
-    Q_DISABLE_COPY(QBoolBlocker)
+    Q_DISABLE_COPY_MOVE(QBoolBlocker)
 public:
     explicit inline QBoolBlocker(bool &b, bool value=true):block(b), reset(b){block = value;}
     inline ~QBoolBlocker(){block = reset; }
@@ -432,9 +432,9 @@ struct Q_CORE_EXPORT QAbstractDynamicMetaObject : public QDynamicMetaObjectData,
 {
     ~QAbstractDynamicMetaObject();
 
-    virtual QAbstractDynamicMetaObject *toDynamicMetaObject(QObject *) override { return this; }
+    QAbstractDynamicMetaObject *toDynamicMetaObject(QObject *) override { return this; }
     virtual int createProperty(const char *, const char *) { return -1; }
-    virtual int metaCall(QObject *, QMetaObject::Call c, int _id, void **a) override
+    int metaCall(QObject *, QMetaObject::Call c, int _id, void **a) override
     { return metaCall(c, _id, a); }
     virtual int metaCall(QMetaObject::Call, int _id, void **) { return _id; } // Compat overload
 };
diff --git a/src/corelib/kernel/qobjectdefs_impl.h b/src/corelib/kernel/qobjectdefs_impl.h
index 8afff1fb98..aa6bd84e95 100644
--- a/src/corelib/kernel/qobjectdefs_impl.h
+++ b/src/corelib/kernel/qobjectdefs_impl.h
@@ -395,7 +395,7 @@ namespace QtPrivate {
     protected:
         ~QSlotObjectBase() {}
     private:
-        Q_DISABLE_COPY(QSlotObjectBase)
+        Q_DISABLE_COPY_MOVE(QSlotObjectBase)
     };
 
     // implementation of QSlotObjectBase for which the slot is a pointer to member function of a QObject
diff --git a/src/corelib/kernel/qppsobject_p.h b/src/corelib/kernel/qppsobject_p.h
index abcf00fa05..a3bf3a5bc1 100644
--- a/src/corelib/kernel/qppsobject_p.h
+++ b/src/corelib/kernel/qppsobject_p.h
@@ -119,7 +119,7 @@ Q_SIGNALS:
 
 private:
     Q_DECLARE_PRIVATE(QPpsObject)
-    Q_DISABLE_COPY(QPpsObject)
+    Q_DISABLE_COPY_MOVE(QPpsObject)
 };
 
 QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qsystemerror.cpp b/src/corelib/kernel/qsystemerror.cpp
index 53c3136857..9d0394e4a5 100644
--- a/src/corelib/kernel/qsystemerror.cpp
+++ b/src/corelib/kernel/qsystemerror.cpp
@@ -152,10 +152,7 @@ QString QSystemError::string(ErrorScope errorScope, int errorCode)
     case NativeError:
 #if defined (Q_OS_WIN)
         return windowsErrorString(errorCode);
-#else
-        //unix: fall through as native and standard library are the same
-        Q_FALLTHROUGH();
-#endif
+#endif // else unix: native and standard library are the same
     case StandardLibraryError:
         return standardLibraryErrorString(errorCode);
     default:
diff --git a/src/corelib/kernel/qtranslator.cpp b/src/corelib/kernel/qtranslator.cpp
index 744bbfbff5..dc39490ab0 100644
--- a/src/corelib/kernel/qtranslator.cpp
+++ b/src/corelib/kernel/qtranslator.cpp
@@ -61,14 +61,8 @@
 #if defined(Q_OS_UNIX) && !defined(Q_OS_INTEGRITY)
 #define QT_USE_MMAP
 #include "private/qcore_unix_p.h"
-#endif
-
-// most of the headers below are already included in qplatformdefs.h
-// also this lacks Large File support but that's probably irrelevant
-#if defined(QT_USE_MMAP)
 // for mmap
 #include <sys/mman.h>
-#include <errno.h>
 #endif
 
 #include <stdlib.h>
@@ -302,7 +296,7 @@ public:
     bool used_mmap : 1;
 #endif
     char *unmapPointer;     // used memory (mmap, new or resource file)
-    quint32 unmapLength;
+    qsizetype unmapLength;
 
     // The resource object in case we loaded the translations from a resource
     QResource *resource;
@@ -322,7 +316,7 @@ public:
     uint numerusRulesLength;
 
     bool do_load(const QString &filename, const QString &directory);
-    bool do_load(const uchar *data, int len, const QString &directory);
+    bool do_load(const uchar *data, qsizetype len, const QString &directory);
     QString do_translate(const char *context, const char *sourceText, const char *comment,
                          int n) const;
     void clear();
@@ -553,7 +547,7 @@ bool QTranslatorPrivate::do_load(const QString &realname, const QString &directo
             return false;
 
         qint64 fileSize = file.size();
-        if (fileSize < MagicLength || quint32(-1) <= fileSize)
+        if (fileSize < MagicLength || fileSize > std::numeric_limits<qsizetype>::max())
             return false;
 
         {
@@ -563,7 +557,7 @@ bool QTranslatorPrivate::do_load(const QString &realname, const QString &directo
                 return false;
         }
 
-        d->unmapLength = quint32(fileSize);
+        d->unmapLength = qsizetype(fileSize);
 
 #ifdef QT_USE_MMAP
 
@@ -571,21 +565,20 @@ bool QTranslatorPrivate::do_load(const QString &realname, const QString &directo
 #define MAP_FILE 0
 #endif
 #ifndef MAP_FAILED
-#define MAP_FAILED -1
+#define MAP_FAILED reinterpret_cast<void *>(-1)
 #endif
 
         int fd = file.handle();
         if (fd >= 0) {
-            char *ptr;
-            ptr = reinterpret_cast<char *>(
-                mmap(0, d->unmapLength,         // any address, whole file
-                     PROT_READ,                 // read-only memory
-                     MAP_FILE | MAP_PRIVATE,    // swap-backed map from file
-                     fd, 0));                   // from offset 0 of fd
-            if (ptr && ptr != reinterpret_cast<char *>(MAP_FAILED)) {
+            int protection = PROT_READ;                 // read-only memory
+            int flags = MAP_FILE | MAP_PRIVATE;         // swap-backed map from file
+            void *ptr = QT_MMAP(nullptr, d->unmapLength,// any address, whole file
+                                protection, flags,
+                                fd, 0);                 // from offset 0 of fd
+            if (ptr != MAP_FAILED) {
                 file.close();
                 d->used_mmap = true;
-                d->unmapPointer = ptr;
+                d->unmapPointer = static_cast<char *>(ptr);
                 ok = true;
             }
         }
@@ -815,7 +808,7 @@ static quint32 read32(const uchar *data)
     return qFromBigEndian<quint32>(data);
 }
 
-bool QTranslatorPrivate::do_load(const uchar *data, int len, const QString &directory)
+bool QTranslatorPrivate::do_load(const uchar *data, qsizetype len, const QString &directory)
 {
     bool ok = true;
     const uchar *end = data + len;
diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h
index ff73c27b6e..f95502e75f 100644
--- a/src/corelib/kernel/qvariant.h
+++ b/src/corelib/kernel/qvariant.h
@@ -55,6 +55,8 @@
 
 #if QT_HAS_INCLUDE(<variant>) && __cplusplus >= 201703L
 #include <variant>
+#elif defined(Q_CLANG_QDOC)
+namespace std { template<typename...> struct variant; }
 #endif
 
 QT_BEGIN_NAMESPACE
@@ -365,7 +367,7 @@ class Q_CORE_EXPORT QVariant
     static inline QVariant fromValue(const T &value)
     { return qVariantFromValue(value); }
 
-#if defined(Q_CLANG_QDOC) || (QT_HAS_INCLUDE(<variant>) && __cplusplus >= 201703L)
+#if QT_HAS_INCLUDE(<variant>) && __cplusplus >= 201703L
     template<typename... Types>
     static inline QVariant fromStdVariant(const std::variant<Types...> &value)
     {