Move creation and management of singletons to QQmlEnginePrivate

Singleton object instances were previously managed by
QQmlType::SingletonInstanceInfo and kept in a shared storage. This caused
concurrency problems when instantiating singleton instances from different
QML engines in different threads.

This patch moves the singleton house-keeping infrastructure to
QQmlEnginePrivate and makes SingletonInstanceInfo immutable.
Singleton objects are stored in a QHash with QQmlType as the key because
the qml type id might be 0 for composite singletons. The public API of
QQmlType is extended to provide more information about singleton types so that
access to SingletonInstanceInfo is not needed.

All internal accesses of singleton objects must now take the same code path via
QQmlEnginePrivate::singletonInstance<T>() which simplifies overall usage of
singletons and scatters less implementation details throughout the code base.

Task-number: QTBUG-75007
Change-Id: I13c5fd21cac2eb7291f2cbcf2c2b504f0f51a07c
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>

7 files changed, 184 insertions, 194 deletions

diff --git a/src/qml/jsruntime/qv4qmlcontext.cpp b/src/qml/jsruntime/qv4qmlcontext.cpp
index d2aa334805..4e917feb2d 100644
--- a/src/qml/jsruntime/qv4qmlcontext.cpp
+++ b/src/qml/jsruntime/qv4qmlcontext.cpp
@@ -231,17 +231,17 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r
             } else if (r.type.isValid()) {
                 if (lookup) {
                     if (r.type.isSingleton()) {
-                        QQmlEngine *e = v4->qmlEngine();
-                        QQmlType::SingletonInstanceInfo *siinfo = r.type.singletonInstanceInfo();
-                        siinfo->init(e);
-                        if (siinfo->qobjectApi(e)) {
+                        QQmlEnginePrivate *e = QQmlEnginePrivate::get(v4->qmlEngine());
+                        if (r.type.isQObjectSingleton() || r.type.isCompositeSingleton()) {
+                            e->singletonInstance<QObject*>(r.type);
                             lookup->qmlContextSingletonLookup.singleton =
                                     static_cast<Heap::Object*>(
                                         Value::fromReturnedValue(
                                             QQmlTypeWrapper::create(v4, nullptr, r.type)
                                         ).heapObject());
                         } else {
-                            QV4::ScopedObject o(scope, QJSValuePrivate::convertedToValue(v4, siinfo->scriptApi(e)));
+                            QJSValue singleton = e->singletonInstance<QJSValue>(r.type);
+                            QV4::ScopedObject o(scope, QJSValuePrivate::convertedToValue(v4, singleton));
                             lookup->qmlContextSingletonLookup.singleton = o->d();
                         }
                         lookup->qmlContextPropertyGetter = QQmlContextWrapper::lookupSingleton;
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index 840aeb534d..19c3469682 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -1057,7 +1057,7 @@ QQmlEngine::~QQmlEngine()
     // XXX TODO: performance -- store list of singleton types separately?
     QList<QQmlType> singletonTypes = QQmlMetaType::qmlSingletonTypes();
     for (const QQmlType &currType : singletonTypes)
-        currType.singletonInstanceInfo()->destroy(this);
+        d->destroySingletonInstance(currType);
 
     delete d->rootContext;
     d->rootContext = nullptr;
@@ -1402,23 +1402,13 @@ void QQmlEngine::setOutputWarningsToStandardError(bool enabled)
 template<>
 QJSValue QQmlEngine::singletonInstance<QJSValue>(int qmlTypeId)
 {
+    Q_D(QQmlEngine);
     QQmlType type = QQmlMetaType::qmlType(qmlTypeId, QQmlMetaType::TypeIdCategory::QmlType);
 
     if (!type.isValid() || !type.isSingleton())
         return QJSValue();
 
-    QQmlType::SingletonInstanceInfo* info = type.singletonInstanceInfo();
-    info->init(this);
-
-    if (QObject* o = info->qobjectApi(this))
-        return this->newQObject(o);
-    else {
-        QJSValue value = info->scriptApi(this);
-        if (!value.isUndefined())
-            return value;
-    }
-
-    return QJSValue();
+    return d->singletonInstance<QJSValue>(type);
 }
 
 /*!
@@ -2445,6 +2435,67 @@ void QQmlEnginePrivate::unregisterInternalCompositeType(QV4::CompiledData::Compi
     m_compositeTypes.remove(compilationUnit->metaTypeId);
 }
 
+template<>
+QJSValue QQmlEnginePrivate::singletonInstance<QJSValue>(const QQmlType &type)
+{
+    Q_Q(QQmlEngine);
+
+    QJSValue value = singletonInstances.value(type);
+    if (!value.isUndefined()) {
+        return value;
+    }
+
+    QQmlType::SingletonInstanceInfo *siinfo = type.singletonInstanceInfo();
+    Q_ASSERT(siinfo != nullptr);
+
+    if (siinfo->scriptCallback) {
+        value = siinfo->scriptCallback(q, q);
+        if (value.isQObject()) {
+            QObject *o = value.toQObject();
+            // even though the object is defined in C++, qmlContext(obj) and qmlEngine(obj)
+            // should behave identically to QML singleton types.
+            q->setContextForObject(o, new QQmlContext(q->rootContext(), q));
+        }
+        singletonInstances.insert(type, value);
+
+    } else if (siinfo->qobjectCallback) {
+        QObject *o = siinfo->qobjectCallback(q, q);
+        if (!o) {
+            qFatal("qmlRegisterSingletonType(): \"%s\" is not available because the callback function returns a null pointer.",
+                   qPrintable(QString::fromUtf8(type.typeName())));
+        }
+        // if this object can use a property cache, create it now
+        QQmlData::ensurePropertyCache(q, o);
+        // even though the object is defined in C++, qmlContext(obj) and qmlEngine(obj)
+        // should behave identically to QML singleton types.
+        q->setContextForObject(o, new QQmlContext(q->rootContext(), q));
+        value = q->newQObject(o);
+        singletonInstances.insert(type, value);
+
+    } else if (!siinfo->url.isEmpty()) {
+        QQmlComponent component(q, siinfo->url, QQmlComponent::PreferSynchronous);
+        QObject *o = component.beginCreate(q->rootContext());
+        value = q->newQObject(o);
+        singletonInstances.insert(type, value);
+        component.completeCreate();
+    }
+
+    return value;
+}
+
+void QQmlEnginePrivate::destroySingletonInstance(const QQmlType &type)
+{
+    Q_ASSERT(type.isSingleton() || type.isCompositeSingleton());
+
+    QObject* o = singletonInstances.take(type).toQObject();
+    if (o) {
+        QQmlData *ddata = QQmlData::get(o, false);
+        if (type.singletonInstanceInfo()->url.isEmpty() && ddata && ddata->indestructible && ddata->explicitIndestructibleSet)
+            return;
+        delete o;
+    }
+}
+
 bool QQmlEnginePrivate::isTypeLoaded(const QUrl &url) const
 {
     return typeLoader.isTypeLoaded(url);
diff --git a/src/qml/qml/qqmlengine.h b/src/qml/qml/qqmlengine.h
index 871e6bd9b4..da91c8fa15 100644
--- a/src/qml/qml/qqmlengine.h
+++ b/src/qml/qml/qqmlengine.h
@@ -175,12 +175,7 @@ Q_QML_EXPORT QJSValue QQmlEngine::singletonInstance<QJSValue>(int qmlTypeId);
 
 template<typename T>
 T QQmlEngine::singletonInstance(int qmlTypeId) {
-    QJSValue instance = singletonInstance<QJSValue>(qmlTypeId);
-    if (!instance.isQObject())
-        return nullptr;
-
-    QObject *object = instance.toQObject();
-    return qobject_cast<T>(object);
+    return qobject_cast<T>(singletonInstance<QJSValue>(qmlTypeId).toQObject());
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlengine_p.h b/src/qml/qml/qqmlengine_p.h
index dab4e54cd6..4f7fb79593 100644
--- a/src/qml/qml/qqmlengine_p.h
+++ b/src/qml/qml/qqmlengine_p.h
@@ -229,6 +229,10 @@ public:
     bool isTypeLoaded(const QUrl &url) const;
     bool isScriptLoaded(const QUrl &url) const;
 
+    template <typename T>
+    T singletonInstance(const QQmlType &type);
+    void destroySingletonInstance(const QQmlType &type);
+
     void sendQuit();
     void sendExit(int retCode = 0);
     void warning(const QQmlError &);
@@ -262,6 +266,8 @@ public:
     mutable QMutex networkAccessManagerMutex;
 
 private:
+    QHash<QQmlType, QJSValue> singletonInstances;
+
     // These members must be protected by a QQmlEnginePrivate::Locker as they are required by
     // the threaded loader.  Only access them through their respective accessor methods.
     QHash<int, QV4::CompiledData::CompilationUnit *> m_compositeTypes;
@@ -437,6 +443,14 @@ QQmlEnginePrivate *QQmlEnginePrivate::get(QV4::ExecutionEngine *e)
     return get(qmlEngine);
 }
 
+template<>
+Q_QML_PRIVATE_EXPORT QJSValue QQmlEnginePrivate::singletonInstance<QJSValue>(const QQmlType &type);
+
+template<typename T>
+T QQmlEnginePrivate::singletonInstance(const QQmlType &type) {
+    return qobject_cast<T>(singletonInstance<QJSValue>(type).toQObject());
+}
+
 QT_END_NAMESPACE
 
 #endif // QQMLENGINE_P_H
diff --git a/src/qml/qml/qqmltype.cpp b/src/qml/qml/qqmltype.cpp
index f5eef8d93b..26ca995756 100644
--- a/src/qml/qml/qqmltype.cpp
+++ b/src/qml/qml/qqmltype.cpp
@@ -51,70 +51,6 @@
 
 QT_BEGIN_NAMESPACE
 
-void QQmlType::SingletonInstanceInfo::init(QQmlEngine *e)
-{
-    if (scriptCallback && scriptApi(e).isUndefined()) {
-        QJSValue value = scriptCallback(e, e);
-        if (value.isQObject()) {
-            QObject *o = value.toQObject();
-            // even though the object is defined in C++, qmlContext(obj) and qmlEngine(obj)
-            // should behave identically to QML singleton types.
-            e->setContextForObject(o, new QQmlContext(e->rootContext(), e));
-        }
-        setScriptApi(e, value);
-    } else if (qobjectCallback && !qobjectApi(e)) {
-        QObject *o = qobjectCallback(e, e);
-        setQObjectApi(e, o);
-        if (!o) {
-            qFatal("qmlRegisterSingletonType(): \"%s\" is not available because the callback function returns a null pointer.", qPrintable(typeName));
-        }
-        // if this object can use a property cache, create it now
-        QQmlData::ensurePropertyCache(e, o);
-        // even though the object is defined in C++, qmlContext(obj) and qmlEngine(obj)
-        // should behave identically to QML singleton types.
-        e->setContextForObject(o, new QQmlContext(e->rootContext(), e));
-    } else if (!url.isEmpty() && !qobjectApi(e)) {
-        QQmlComponent component(e, url, QQmlComponent::PreferSynchronous);
-        QObject *o = component.beginCreate(e->rootContext());
-        setQObjectApi(e, o);
-        if (o)
-            component.completeCreate();
-    }
-}
-
-void QQmlType::SingletonInstanceInfo::destroy(QQmlEngine *e)
-{
-    // cleans up the engine-specific singleton instances if they exist.
-    scriptApis.remove(e);
-    QObject *o = qobjectApis.take(e);
-    if (o) {
-        QQmlData *ddata = QQmlData::get(o, false);
-        if (url.isEmpty() && ddata && ddata->indestructible && ddata->explicitIndestructibleSet)
-            return;
-        delete o;
-    }
-}
-
-void QQmlType::SingletonInstanceInfo::setQObjectApi(QQmlEngine *e, QObject *o)
-{
-    qobjectApis.insert(e, o);
-}
-
-QObject *QQmlType::SingletonInstanceInfo::qobjectApi(QQmlEngine *e) const
-{
-    return qobjectApis.value(e);
-}
-
-void QQmlType::SingletonInstanceInfo::setScriptApi(QQmlEngine *e, const QJSValue &v)
-{
-    scriptApis.insert(e, v);
-}
-
-QJSValue QQmlType::SingletonInstanceInfo::scriptApi(QQmlEngine *e) const
-{
-    return scriptApis.value(e);
-}
-
 QQmlTypePrivate::QQmlTypePrivate(QQmlType::RegistrationType type)
     : regType(type), iid(nullptr), typeId(0), listId(0), revision(0),
     containsRevisionedAttributes(false), baseMetaObject(nullptr),
@@ -636,6 +572,16 @@ bool QQmlType::isCompositeSingleton() const
     return d && d->regType == CompositeSingletonType;
 }
 
+bool QQmlType::isQObjectSingleton() const
+{
+    return d && d->regType == SingletonType && d->extraData.sd->singletonInstanceInfo->qobjectCallback;
+}
+
+bool QQmlType::isQJSValueSingleton() const
+{
+    return d && d->regType == SingletonType && d->extraData.sd->singletonInstanceInfo->scriptCallback;
+}
+
 int QQmlType::typeId() const
 {
     return d ? d->typeId : -1;
diff --git a/src/qml/qml/qqmltype_p.h b/src/qml/qml/qqmltype_p.h
index 0e59b1be06..7b326ce1c7 100644
--- a/src/qml/qml/qqmltype_p.h
+++ b/src/qml/qml/qqmltype_p.h
@@ -118,6 +118,8 @@ public:
     bool isInterface() const;
     bool isComposite() const;
     bool isCompositeSingleton() const;
+    bool isQObjectSingleton() const;
+    bool isQJSValueSingleton() const;
 
     int typeId() const;
     int qListTypeId() const;
@@ -138,28 +140,13 @@ public:
 
     int index() const;
 
-    class Q_QML_PRIVATE_EXPORT SingletonInstanceInfo
+    struct Q_QML_PRIVATE_EXPORT SingletonInstanceInfo
     {
-    public:
-        SingletonInstanceInfo()
-            : scriptCallback(nullptr), qobjectCallback(nullptr), instanceMetaObject(nullptr) {}
-
-        QJSValue (*scriptCallback)(QQmlEngine *, QJSEngine *);
-        QObject *(*qobjectCallback)(QQmlEngine *, QJSEngine *);
-        const QMetaObject *instanceMetaObject;
+        QJSValue (*scriptCallback)(QQmlEngine *, QJSEngine *) = nullptr;
+        QObject *(*qobjectCallback)(QQmlEngine *, QJSEngine *) = nullptr;
+        const QMetaObject *instanceMetaObject = nullptr;
         QString typeName;
         QUrl url; // used by composite singletons
-
-        void setQObjectApi(QQmlEngine *, QObject *);
-        QObject *qobjectApi(QQmlEngine *) const;
-        void setScriptApi(QQmlEngine *, const QJSValue &);
-        QJSValue scriptApi(QQmlEngine *) const;
-
-        void init(QQmlEngine *);
-        void destroy(QQmlEngine *);
-
-        QHash<QQmlEngine *, QJSValue> scriptApis;
-        QHash<QQmlEngine *, QObject *> qobjectApis;
     };
     SingletonInstanceInfo *singletonInstanceInfo() const;
 
diff --git a/src/qml/qml/qqmltypewrapper.cpp b/src/qml/qml/qqmltypewrapper.cpp
index b72d82ffbc..3e72f5b324 100644
--- a/src/qml/qml/qqmltypewrapper.cpp
+++ b/src/qml/qml/qqmltypewrapper.cpp
@@ -89,10 +89,8 @@ QObject* QQmlTypeWrapper::singletonObject() const
     if (!isSingleton())
         return nullptr;
 
-    QQmlEngine *e = engine()->qmlEngine();
-    QQmlType::SingletonInstanceInfo *siinfo = d()->type().singletonInstanceInfo();
-    siinfo->init(e);
-    return siinfo->qobjectApi(e);
+    QQmlEnginePrivate *e = QQmlEnginePrivate::get(engine()->qmlEngine());
+    return e->singletonInstance<QObject*>(d()->type());
 }
 
 QVariant QQmlTypeWrapper::toVariant() const
@@ -101,13 +99,12 @@ QVariant QQmlTypeWrapper::toVariant() const
     if (!isSingleton())
         return QVariant();
 
-    QQmlEngine *e = engine()->qmlEngine();
-    QQmlType::SingletonInstanceInfo *siinfo = d()->type().singletonInstanceInfo();
-    siinfo->init(e);
-    if (QObject *qobjectSingleton = siinfo->qobjectApi(e))
-        return QVariant::fromValue<QObject*>(qobjectSingleton);
+    QQmlEnginePrivate *e = QQmlEnginePrivate::get(engine()->qmlEngine());
+    const QQmlType type = d()->type();
+    if (type.isQJSValueSingleton())
+        return QVariant::fromValue<QJSValue>(e->singletonInstance<QJSValue>(type));
 
-    return QVariant::fromValue<QJSValue>(siinfo->scriptApi(e));
+    return QVariant::fromValue<QObject*>(e->singletonInstance<QObject*>(type));
 }
 
 
@@ -195,50 +192,51 @@ ReturnedValue QQmlTypeWrapper::virtualGet(const Managed *m, PropertyKey id, cons
 
         // singleton types are handled differently to other types.
         if (type.isSingleton()) {
-            QQmlEngine *e = v4->qmlEngine();
-            QQmlType::SingletonInstanceInfo *siinfo = type.singletonInstanceInfo();
-            siinfo->init(e);
-
-            QObject *qobjectSingleton = siinfo->qobjectApi(e);
-            if (qobjectSingleton) {
-
-                // check for enum value
-                const bool includeEnums = w->d()->mode == Heap::QQmlTypeWrapper::IncludeEnums;
-                if (includeEnums && name->startsWithUpper()) {
-                    bool ok = false;
-                    int value = enumForSingleton(v4, name, qobjectSingleton, type, &ok);
-                    if (ok)
-                        return QV4::Value::fromInt32(value).asReturnedValue();
-
-                    value = type.scopedEnumIndex(QQmlEnginePrivate::get(v4->qmlEngine()), name, &ok);
-                    if (ok) {
-                        Scoped<QQmlScopedEnumWrapper> enumWrapper(scope, v4->memoryManager->allocate<QQmlScopedEnumWrapper>());
-                        enumWrapper->d()->typePrivate = type.priv();
-                        QQmlType::refHandle(enumWrapper->d()->typePrivate);
-                        enumWrapper->d()->scopeEnumIndex = value;
-                        return enumWrapper.asReturnedValue();
+            QQmlEnginePrivate *e = QQmlEnginePrivate::get(v4->qmlEngine());
+            QJSValue scriptSingleton;
+            if (type.isQObjectSingleton() || type.isCompositeSingleton()) {
+                if (QObject *qobjectSingleton = e->singletonInstance<QObject*>(type)) {
+                    // check for enum value
+                    const bool includeEnums = w->d()->mode == Heap::QQmlTypeWrapper::IncludeEnums;
+                    if (includeEnums && name->startsWithUpper()) {
+                        bool ok = false;
+                        int value = enumForSingleton(v4, name, qobjectSingleton, type, &ok);
+                        if (ok)
+                            return QV4::Value::fromInt32(value).asReturnedValue();
+
+                        value = type.scopedEnumIndex(QQmlEnginePrivate::get(v4->qmlEngine()), name, &ok);
+                        if (ok) {
+                            Scoped<QQmlScopedEnumWrapper> enumWrapper(scope, v4->memoryManager->allocate<QQmlScopedEnumWrapper>());
+                            enumWrapper->d()->typePrivate = type.priv();
+                            QQmlType::refHandle(enumWrapper->d()->typePrivate);
+                            enumWrapper->d()->scopeEnumIndex = value;
+                            return enumWrapper.asReturnedValue();
+                        }
                     }
-                }
 
-                // check for property.
-                bool ok;
-                const ReturnedValue result = QV4::QObjectWrapper::getQmlProperty(v4, context, qobjectSingleton, name, QV4::QObjectWrapper::IgnoreRevision, &ok);
-                if (hasProperty)
-                    *hasProperty = ok;
-
-                // Warn when attempting to access a lowercased enum value, singleton case
-                if (!ok && includeEnums && !name->startsWithUpper()) {
-                    enumForSingleton(v4, name, qobjectSingleton, type, &ok);
-                    if (ok)
-                        return throwLowercaseEnumError(v4, name, type);
-                }
+                    // check for property.
+                    bool ok;
+                    const ReturnedValue result = QV4::QObjectWrapper::getQmlProperty(v4, context, qobjectSingleton, name, QV4::QObjectWrapper::IgnoreRevision, &ok);
+                    if (hasProperty)
+                        *hasProperty = ok;
+
+                    // Warn when attempting to access a lowercased enum value, singleton case
+                    if (!ok && includeEnums && !name->startsWithUpper()) {
+                        enumForSingleton(v4, name, qobjectSingleton, type, &ok);
+                        if (ok)
+                            return throwLowercaseEnumError(v4, name, type);
+                    }
 
-                return result;
-            } else if (!siinfo->scriptApi(e).isUndefined()) {
-                // NOTE: if used in a binding, changes will not trigger re-evaluation since non-NOTIFYable.
-                QV4::ScopedObject o(scope, QJSValuePrivate::convertedToValue(v4, siinfo->scriptApi(e)));
-                if (!!o)
-                    return o->get(name);
+                    return result;
+                }
+            } else if (type.isQJSValueSingleton()) {
+                QJSValue scriptSingleton = e->singletonInstance<QJSValue>(type);
+                if (!scriptSingleton.isUndefined()) {
+                    // NOTE: if used in a binding, changes will not trigger re-evaluation since non-NOTIFYable.
+                    QV4::ScopedObject o(scope, QJSValuePrivate::convertedToValue(v4, scriptSingleton));
+                    if (!!o)
+                        return o->get(name);
+                }
             }
 
             // Fall through to base implementation
@@ -343,21 +341,22 @@ bool QQmlTypeWrapper::virtualPut(Managed *m, PropertyKey id, const Value &value,
             return QV4::QObjectWrapper::setQmlProperty(scope.engine, context, ao, name, QV4::QObjectWrapper::IgnoreRevision, value);
         return false;
     } else if (type.isSingleton()) {
-        QQmlEngine *e = scope.engine->qmlEngine();
-        QQmlType::SingletonInstanceInfo *siinfo = type.singletonInstanceInfo();
-        siinfo->init(e);
-
-        QObject *qobjectSingleton = siinfo->qobjectApi(e);
-        if (qobjectSingleton) {
-            return QV4::QObjectWrapper::setQmlProperty(scope.engine, context, qobjectSingleton, name, QV4::QObjectWrapper::IgnoreRevision, value);
-        } else if (!siinfo->scriptApi(e).isUndefined()) {
-            QV4::ScopedObject apiprivate(scope, QJSValuePrivate::convertedToValue(scope.engine, siinfo->scriptApi(e)));
-            if (!apiprivate) {
-                QString error = QLatin1String("Cannot assign to read-only property \"") + name->toQString() + QLatin1Char('\"');
-                scope.engine->throwError(error);
-                return false;
-            } else {
-                return apiprivate->put(name, value);
+        QQmlEnginePrivate *e = QQmlEnginePrivate::get(scope.engine->qmlEngine());
+        if (type.isQObjectSingleton() || type.isCompositeSingleton()) {
+            if (QObject *qobjectSingleton = e->singletonInstance<QObject*>(type))
+                return QV4::QObjectWrapper::setQmlProperty(scope.engine, context, qobjectSingleton, name, QV4::QObjectWrapper::IgnoreRevision, value);
+
+        } else {
+            QJSValue scriptSingleton = e->singletonInstance<QJSValue>(type);
+            if (!scriptSingleton.isUndefined()) {
+                QV4::ScopedObject apiprivate(scope, QJSValuePrivate::convertedToValue(scope.engine, scriptSingleton));
+                if (!apiprivate) {
+                    QString error = QLatin1String("Cannot assign to read-only property \"") + name->toQString() + QLatin1Char('\"');
+                    scope.engine->throwError(error);
+                    return false;
+                } else {
+                    return apiprivate->put(name, value);
+                }
             }
         }
     }
@@ -449,27 +448,25 @@ ReturnedValue QQmlTypeWrapper::virtualResolveLookupGetter(const Object *object,
     if (type.isValid()) {
 
         if (type.isSingleton()) {
-            QQmlEngine *e = engine->qmlEngine();
-            QQmlType::SingletonInstanceInfo *siinfo = type.singletonInstanceInfo();
-            siinfo->init(e);
-
-            QObject *qobjectSingleton = siinfo->qobjectApi(e);
-            if (qobjectSingleton) {
-
-                const bool includeEnums = w->d()->mode == Heap::QQmlTypeWrapper::IncludeEnums;
-                if (!includeEnums || !name->startsWithUpper()) {
-                    QQmlData *ddata = QQmlData::get(qobjectSingleton, false);
-                    if (ddata && ddata->propertyCache) {
-                        ScopedValue val(scope, Value::fromReturnedValue(QV4::QObjectWrapper::wrap(engine, qobjectSingleton)));
-                        QQmlPropertyData *property = ddata->propertyCache->property(name.getPointer(), qobjectSingleton, qmlContext);
-                        if (property) {
-                            lookup->qobjectLookup.ic = This->internalClass();
-                            lookup->qobjectLookup.staticQObject = static_cast<Heap::QObjectWrapper *>(val->heapObject());
-                            lookup->qobjectLookup.propertyCache = ddata->propertyCache;
-                            lookup->qobjectLookup.propertyCache->addref();
-                            lookup->qobjectLookup.propertyData = property;
-                            lookup->getter = QV4::QObjectWrapper::lookupGetter;
-                            return lookup->getter(lookup, engine, *This);
+            QQmlEnginePrivate *e = QQmlEnginePrivate::get(engine->qmlEngine());
+            if (type.isQObjectSingleton() || type.isCompositeSingleton()) {
+                if (QObject *qobjectSingleton = e->singletonInstance<QObject*>(type)) {
+                    const bool includeEnums = w->d()->mode == Heap::QQmlTypeWrapper::IncludeEnums;
+                    if (!includeEnums || !name->startsWithUpper()) {
+                        QQmlData *ddata = QQmlData::get(qobjectSingleton, false);
+                        if (ddata && ddata->propertyCache) {
+                            ScopedValue val(scope, Value::fromReturnedValue(QV4::QObjectWrapper::wrap(engine, qobjectSingleton)));
+                            QQmlPropertyData *property = ddata->propertyCache->property(name.getPointer(), qobjectSingleton, qmlContext);
+                            if (property) {
+                                lookup->qobjectLookup.ic = This->internalClass();
+                                lookup->qobjectLookup.staticQObject = static_cast<Heap::QObjectWrapper *>(val->heapObject());
+                                lookup->qobjectLookup.propertyCache = ddata->propertyCache;
+                                lookup->qobjectLookup.propertyCache->addref();
+                                lookup->qobjectLookup.propertyData = property;
+                                lookup->getter = QV4::QObjectWrapper::lookupGetter;
+                                return lookup->getter(lookup, engine, *This);
+                            }
+                            // Fall through to base implementation
                         }
                         // Fall through to base implementation
                     }