1 files changed, 87 insertions, 6 deletions

diff --git a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
index 5665775258..8bee4ef260 100644
--- a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
+++ b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
@@ -326,6 +326,7 @@ private slots:
 
     void listContainingDeletedObject();
     void overrideSingleton();
+    void revisionedPropertyOfAttachedObjectProperty();
 
     void arrayToContainer();
     void qualifiedScopeInCustomParser();
@@ -4881,8 +4882,9 @@ static void beginDeferredOnce(QQmlEnginePrivate *enginePriv,
         QQmlComponentPrivate::ConstructionState *state = new QQmlComponentPrivate::ConstructionState;
         state->completePending = true;
 
-        QQmlContextData *creationContext = nullptr;
-        state->creator.reset(new QQmlObjectCreator(deferData->context->parent, deferData->compilationUnit, creationContext));
+        state->creator.reset(new QQmlObjectCreator(
+                                 deferData->context->parent(), deferData->compilationUnit,
+                                 QQmlRefPointer<QQmlContextData>()));
 
         enginePriv->inProgressCreations++;
 
@@ -4914,7 +4916,7 @@ static void testExecuteDeferredOnce(const QQmlProperty &property)
     QObject *object = property.object();
     QQmlData *data = QQmlData::get(object);
     if (data && !data->deferredData.isEmpty() && !data->wasDeleted(object)) {
-        QQmlEnginePrivate *ep = QQmlEnginePrivate::get(data->context->engine);
+        QQmlEnginePrivate *ep = QQmlEnginePrivate::get(data->context->engine());
 
         QQmlComponentPrivate::DeferredState state;
         beginDeferredOnce(ep, property, &state);
@@ -5451,7 +5453,7 @@ void tst_qqmllanguage::selfReference()
 
     const QMetaObject *metaObject = o->metaObject();
     QMetaProperty selfProperty = metaObject->property(metaObject->indexOfProperty("self"));
-    QCOMPARE(selfProperty.userType(), compilationUnit->metaTypeId);
+    QCOMPARE(selfProperty.userType(), compilationUnit->metaTypeId.id());
 
     QByteArray typeName = selfProperty.typeName();
     QVERIFY(typeName.endsWith('*'));
@@ -5460,7 +5462,7 @@ void tst_qqmllanguage::selfReference()
 
     QMetaMethod selfFunction = metaObject->method(metaObject->indexOfMethod("returnSelf()"));
     QVERIFY(selfFunction.isValid());
-    QCOMPARE(selfFunction.returnType(), compilationUnit->metaTypeId);
+    QCOMPARE(selfFunction.returnType(), compilationUnit->metaTypeId.id());
 
     QMetaMethod selfSignal;
 
@@ -5474,7 +5476,7 @@ void tst_qqmllanguage::selfReference()
 
     QVERIFY(selfSignal.isValid());
     QCOMPARE(selfSignal.parameterCount(), 1);
-    QCOMPARE(selfSignal.parameterType(0), compilationUnit->metaTypeId);
+    QCOMPARE(selfSignal.parameterType(0), compilationUnit->metaTypeId.id());
 }
 
 void tst_qqmllanguage::selfReferencingSingleton()
@@ -5551,6 +5553,85 @@ void tst_qqmllanguage::overrideSingleton()
     check("uncreatable", "UncreatableSingleton");
 }
 
+class AttachedObject;
+class InnerObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool revisionedProperty READ revisionedProperty WRITE setRevisionedProperty
+               NOTIFY revisionedPropertyChanged REVISION 2)
+
+public:
+    InnerObject(QObject *parent = nullptr) : QObject(parent) {}
+
+    bool revisionedProperty() const { return m_revisionedProperty; }
+    void setRevisionedProperty(bool revisionedProperty)
+    {
+        if (revisionedProperty != m_revisionedProperty) {
+            m_revisionedProperty = revisionedProperty;
+            emit revisionedPropertyChanged();
+        }
+    }
+
+    static AttachedObject *qmlAttachedProperties(QObject *object);
+
+signals:
+    Q_REVISION(2) void revisionedPropertyChanged();
+
+private:
+    bool m_revisionedProperty = false;
+};
+
+class AttachedObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(InnerObject *attached READ attached CONSTANT)
+
+public:
+    explicit AttachedObject(QObject *parent = nullptr) :
+        QObject(parent),
+        m_attached(new InnerObject(this))
+    {}
+
+    InnerObject *attached() const { return m_attached; }
+
+private:
+    InnerObject *m_attached;
+};
+
+class OuterObject : public QObject
+{
+    Q_OBJECT
+public:
+    explicit OuterObject(QObject *parent = nullptr) : QObject(parent) {}
+};
+
+AttachedObject *InnerObject::qmlAttachedProperties(QObject *object)
+{
+    return new AttachedObject(object);
+}
+
+QML_DECLARE_TYPE(InnerObject)
+QML_DECLARE_TYPEINFO(InnerObject, QML_HAS_ATTACHED_PROPERTIES)
+
+void tst_qqmllanguage::revisionedPropertyOfAttachedObjectProperty()
+{
+    qmlRegisterAnonymousType<AttachedObject>("foo", 2);
+    qmlRegisterType<InnerObject>("foo", 2, 0, "InnerObject");
+    qmlRegisterType<InnerObject, 2>("foo", 2, 2, "InnerObject");
+    qmlRegisterType<OuterObject>("foo", 2, 2, "OuterObject");
+
+    QQmlEngine engine;
+    QQmlComponent component(&engine);
+    component.setData("import foo 2.2\n"
+                      "OuterObject {\n"
+                      "    InnerObject.attached.revisionedProperty: true\n"
+                      "}", QUrl());
+
+    QVERIFY(component.isReady());
+    QScopedPointer<QObject> obj(component.create());
+    QVERIFY(!obj.isNull());
+}
+
 void tst_qqmllanguage::inlineComponent()
 {
     QFETCH(QUrl, componentUrl);