8 files changed, 120 insertions, 13 deletions
diff --git a/src/corelib/itemmodels/qrangemodel_impl.h b/src/corelib/itemmodels/qrangemodel_impl.h
index 0233727f848..f6b08099fe7 100644
--- a/src/corelib/itemmodels/qrangemodel_impl.h
+++ b/src/corelib/itemmodels/qrangemodel_impl.h
@@ -1373,25 +1373,34 @@ public:
                 using multi_role = QRangeModelDetails::is_multi_role<value_type>;
 
                 auto setRangeModelDataRole = [&target, &data]{
-                    auto &targetRef = QRangeModelDetails::refTo(target);
                     constexpr auto targetMetaType = QMetaType::fromType<value_type>();
                     const auto dataMetaType = data.metaType();
                     constexpr bool isWrapped = QRangeModelDetails::is_wrapped<value_type>();
                     if constexpr (!std::is_copy_assignable_v<wrapped_value_type>) {
                         // we don't support replacing objects that are stored as raw pointers,
                         // as this makes object ownership very messy. But we can replace objects
-                        // stored in smart pointers.
-                        if constexpr (isWrapped && !std::is_pointer_v<value_type>
-                                      && std::is_copy_assignable_v<value_type>) {
-                            if (data.canConvert(targetMetaType)) {
-                                target = data.value<value_type>();
-                                return true;
+                        // stored in smart pointers, and we can initialize raw nullptr objects.
+                        if constexpr (isWrapped) {
+                            constexpr bool is_raw_pointer = std::is_pointer_v<value_type>;
+                            if constexpr (!is_raw_pointer && std::is_copy_assignable_v<value_type>) {
+                                if (data.canConvert(targetMetaType)) {
+                                    target = data.value<value_type>();
+                                    return true;
+                                }
+                            } else if constexpr (is_raw_pointer) {
+                                if (!QRangeModelDetails::isValid(target) && data.canConvert(targetMetaType)) {
+                                    target = data.value<value_type>();
+                                    return true;
+                                }
+                            } else {
+                                Q_UNUSED(target);
                             }
                         }
                         // Otherwise we have a move-only or polymorph type. fall through to
                         // error handling.
                     } else if constexpr (isWrapped) {
                         if (QRangeModelDetails::isValid(target)) {
+                            auto &targetRef = QRangeModelDetails::refTo(target);
                             // we need to get a wrapped value type out of the QVariant, which
                             // might carry a pointer. We have to try all alternatives.
                             if (const auto mt = QMetaType::fromType<wrapped_value_type>();
@@ -1405,10 +1414,10 @@ public:
                             }
                         }
                     } else if (targetMetaType == dataMetaType) {
-                        targetRef = data.value<value_type>();
+                        QRangeModelDetails::refTo(target) = data.value<value_type>();
                         return true;
                     } else if (dataMetaType.flags() & QMetaType::PointerToGadget) {
-                        targetRef = *data.value<value_type *>();
+                        QRangeModelDetails::refTo(target) = *data.value<value_type *>();
                         return true;
                     }
 #ifndef QT_NO_DEBUG
@@ -1463,6 +1472,13 @@ public:
             };
 
             success = writeAt(index, writeData);
+
+            if constexpr (itemsAreQObjects) {
+                if (success && isRangeModelRole(role) && this->autoConnectPolicy() == AutoConnectPolicy::Full) {
+                    if (QObject *item = data.value<QObject *>())
+                        Self::connectProperties(index, item, m_data.context, m_data.properties);
+                }
+            }
         }
         return success;
     }
diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp
index 24cc58829c8..c7e50788b45 100644
--- a/src/corelib/kernel/qmetaobject.cpp
+++ b/src/corelib/kernel/qmetaobject.cpp
@@ -469,6 +469,33 @@ QMetaType QMetaObject::metaType() const
     }
 }
 
+static inline QByteArrayView objectMetaObjectHash(const QMetaObject *m)
+{
+    // metaObjectHash didn't exist before revision 14
+    if (QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && priv(m->d.data)->revision < 14)
+        return {};
+    const auto index = priv(m->d.data)->metaObjectHashIndex;
+    if (index == -1)
+        return {};
+    return stringDataView(m, index);
+}
+
+/*!
+    \since 6.11
+
+    Returns the revisioned hash of the contents of this QMetaObject or nullptr.
+
+    The hash has the following format <hash_revision>$<hash_b64>, where
+    hash_revision is an integer and hash_b64 is the base64 encoding of the
+    hash.
+
+    Note that only hashes of the same revision should be compared.
+*/
+const char *QMetaObject::metaObjectHash() const
+{
+    return objectMetaObjectHash(this).constData();
+}
+
 /*!
     Returns the method offset for this class; i.e. the index position
     of this class's first member function.
diff --git a/src/corelib/kernel/qmetaobject_p.h b/src/corelib/kernel/qmetaobject_p.h
index bfda30fda28..7264d2a956f 100644
--- a/src/corelib/kernel/qmetaobject_p.h
+++ b/src/corelib/kernel/qmetaobject_p.h
@@ -124,6 +124,7 @@ struct QMetaObjectPrivate
     int constructorCount, constructorData;
     int flags;
     int signalCount;
+    int metaObjectHashIndex;
 
     static inline const QMetaObjectPrivate *get(const QMetaObject *metaobject)
     { return reinterpret_cast<const QMetaObjectPrivate*>(metaobject->d.data); }
diff --git a/src/corelib/kernel/qmetaobjectbuilder.cpp b/src/corelib/kernel/qmetaobjectbuilder.cpp
index 6065bf2baea..9af6de73680 100644
--- a/src/corelib/kernel/qmetaobjectbuilder.cpp
+++ b/src/corelib/kernel/qmetaobjectbuilder.cpp
@@ -558,6 +558,8 @@ QMetaPropertyBuilder QMetaObjectBuilder::addProperty(const QMetaProperty &protot
     property.setEnumOrFlag(prototype.isEnumType());
     property.setConstant(prototype.isConstant());
     property.setFinal(prototype.isFinal());
+    property.setVirtual(prototype.isVirtual());
+    property.setOverride(prototype.isOverride());
     property.setRevision(prototype.revision());
     if (prototype.hasNotifySignal()) {
         // Find an existing method for the notify signal, or add a new one.
@@ -1177,10 +1179,11 @@ static int buildMetaObject(QMetaObjectBuilderPrivate *d, char *buf,
     int methodParametersDataSize = aggregateParameterCount(d->methods)
              + aggregateParameterCount(d->constructors);
     if constexpr (mode == Construct) {
-        static_assert(QMetaObjectPrivate::OutputRevision == 13, "QMetaObjectBuilder should generate the same version as moc");
+        static_assert(QMetaObjectPrivate::OutputRevision == 14, "QMetaObjectBuilder should generate the same version as moc");
         pmeta->revision = QMetaObjectPrivate::OutputRevision;
         pmeta->flags = d->flags.toInt() | AllocatedMetaObject;
         pmeta->className = 0;   // Class name is always the first string.
+        pmeta->metaObjectHashIndex = -1;   // TODO support hash in the builder too
         //pmeta->signalCount is handled in the "output method loop" as an optimization.
 
         pmeta->classInfoCount = d->classInfoNames.size();
@@ -2068,6 +2071,32 @@ bool QMetaPropertyBuilder::isFinal() const
 }
 
 /*!
+    Returns \c true if the property is virtual; otherwise returns \c false.
+    The default value is false.
+*/
+bool QMetaPropertyBuilder::isVirtual() const
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        return d->flag(Virtual);
+    else
+        return false;
+}
+
+/*!
+    Returns \c true if the property does override; otherwise returns \c false.
+    The default value is false.
+*/
+bool QMetaPropertyBuilder::isOverride() const
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        return d->flag(Override);
+    else
+        return false;
+}
+
+/*!
  * Returns \c true if the property is an alias.
  * The default value is false
  */
@@ -2239,6 +2268,30 @@ void QMetaPropertyBuilder::setFinal(bool value)
 }
 
 /*!
+    Sets the \c VIRTUAL flag on this property to \a value.
+
+ \sa isFinal()
+*/
+void QMetaPropertyBuilder::setVirtual(bool value)
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        d->setFlag(Virtual, value);
+}
+
+/*!
+    Sets the \c OVERRIDE flag on this property to \a value.
+
+ \sa isOverride()
+*/
+void QMetaPropertyBuilder::setOverride(bool value)
+{
+    QMetaPropertyBuilderPrivate *d = d_func();
+    if (d)
+        d->setFlag(Override, value);
+}
+
+/*!
    Sets the \c ALIAS flag on this property to \a value
  */
 void QMetaPropertyBuilder::setAlias(bool value)
diff --git a/src/corelib/kernel/qmetaobjectbuilder_p.h b/src/corelib/kernel/qmetaobjectbuilder_p.h
index 563704d60e6..9591944602a 100644
--- a/src/corelib/kernel/qmetaobjectbuilder_p.h
+++ b/src/corelib/kernel/qmetaobjectbuilder_p.h
@@ -214,6 +214,8 @@ public:
     bool isEnumOrFlag() const;
     bool isConstant() const;
     bool isFinal() const;
+    bool isVirtual() const;
+    bool isOverride() const;
     bool isAlias() const;
     bool isBindable() const;
     bool isRequired() const;
@@ -229,6 +231,8 @@ public:
     void setEnumOrFlag(bool value);
     void setConstant(bool value);
     void setFinal(bool value);
+    void setVirtual(bool value);
+    void setOverride(bool value);
     void setAlias(bool value);
     void setBindable(bool value);
     void setRequired(bool value);
diff --git a/src/corelib/kernel/qobjectdefs.h b/src/corelib/kernel/qobjectdefs.h
index 848102cc57a..d3e761982f5 100644
--- a/src/corelib/kernel/qobjectdefs.h
+++ b/src/corelib/kernel/qobjectdefs.h
@@ -247,6 +247,8 @@ struct Q_CORE_EXPORT QMetaObject
 
     QMetaType metaType() const;
 
+    const char *metaObjectHash() const;
+
     int methodOffset() const;
     int enumeratorOffset() const;
     int propertyOffset() const;
diff --git a/src/corelib/kernel/qtmocconstants.h b/src/corelib/kernel/qtmocconstants.h
index 260ac2fa5f8..822e02e6c8e 100644
--- a/src/corelib/kernel/qtmocconstants.h
+++ b/src/corelib/kernel/qtmocconstants.h
@@ -30,7 +30,8 @@ namespace QtMocConstants {
 // revision 11 is Qt 6.5: The metatype for void is stored in the metatypes array
 // revision 12 is Qt 6.6: It adds the metatype for enums
 // revision 13 is Qt 6.9: Adds support for 64-bit QFlags and moves the method revision
-enum { OutputRevision = 13 };   // Used by moc, qmetaobjectbuilder and qdbus
+// revision 14 is Qt 6.11: Adds a hash of meta object contents
+enum { OutputRevision = 14 };   // Used by moc, qmetaobjectbuilder and qdbus
 
 enum PropertyFlags : uint {
     Invalid = 0x00000000,
diff --git a/src/corelib/kernel/qtmochelpers.h b/src/corelib/kernel/qtmochelpers.h
index 4c549e78ad5..3d2b59d2a73 100644
--- a/src/corelib/kernel/qtmochelpers.h
+++ b/src/corelib/kernel/qtmochelpers.h
@@ -511,7 +511,8 @@ template <typename ObjectType, typename Unique, typename Strings,
           typename Constructors = UintData<>, typename ClassInfo = detail::UintDataBlock<0, 0>>
 constexpr auto metaObjectData(uint flags, const Strings &strings,
                               const Methods &methods, const Properties &properties,
-                              const Enums &enums, const Constructors &constructors = {},
+                              const Enums &enums, int qt_metaObjectHashIndex = -1,
+                              const Constructors &constructors = {},
                               const ClassInfo &classInfo = {})
 {
     constexpr uint MetaTypeCount = Properties::metaTypeCount()
@@ -520,7 +521,7 @@ constexpr auto metaObjectData(uint flags, const Strings &strings,
             + Methods::metaTypeCount()
             + Constructors::metaTypeCount();
 
-    constexpr uint HeaderSize = 14;
+    constexpr uint HeaderSize = 15;
     constexpr uint TotalSize = HeaderSize
             + Properties::dataSize()
             + Enums::dataSize()
@@ -582,6 +583,8 @@ constexpr auto metaObjectData(uint flags, const Strings &strings,
         }
     }
 
+    data[14] = qt_metaObjectHashIndex;
+
     return result;
 }