Merge remote-tracking branch 'origin/5.13' into dev

 Conflicts:
	src/qml/jsruntime/qv4value_p.h
	src/qml/qml/qqmlmetatype.cpp
	src/qml/qml/qqmltypewrapper.cpp
	src/quick/items/qquicktableview.cpp

Change-Id: I684f8e01a711580512848bf1253f39b39fcbf4c7

1 files changed, 38 insertions, 5 deletions

diff --git a/src/qml/qml/qqmltypewrapper.cpp b/src/qml/qml/qqmltypewrapper.cpp
index 9db089c330..57c4eec879 100644
--- a/src/qml/qml/qqmltypewrapper.cpp
+++ b/src/qml/qml/qqmltypewrapper.cpp
@@ -454,16 +454,16 @@ ReturnedValue QQmlTypeWrapper::virtualResolveLookupGetter(const Object *object,
                     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());
+                                ScopedValue val(scope, Value::fromReturnedValue(QV4::QObjectWrapper::wrap(engine, qobjectSingleton)));
+                                lookup->qobjectLookup.qmlTypeIc = This->internalClass();
+                                lookup->qobjectLookup.ic = val->objectValue()->internalClass();
                                 lookup->qobjectLookup.propertyCache = ddata->propertyCache;
                                 lookup->qobjectLookup.propertyCache->addref();
                                 lookup->qobjectLookup.propertyData = property;
-                                lookup->getter = QV4::QObjectWrapper::lookupGetter;
-                                return lookup->getter(lookup, engine, *This);
+                                lookup->getter = QQmlTypeWrapper::lookupSingletonProperty;
+                                return lookup->getter(lookup, engine, *object);
                             }
                             // Fall through to base implementation
                         }
@@ -485,6 +485,39 @@ bool QQmlTypeWrapper::virtualResolveLookupSetter(Object *object, ExecutionEngine
     return Object::virtualResolveLookupSetter(object, engine, lookup, value);
 }
 
+ReturnedValue QQmlTypeWrapper::lookupSingletonProperty(Lookup *l, ExecutionEngine *engine, const Value &object)
+{
+    const auto revertLookup = [l, engine, &object]() {
+        l->qobjectLookup.propertyCache->release();
+        l->qobjectLookup.propertyCache = nullptr;
+        l->getter = Lookup::getterGeneric;
+        return Lookup::getterGeneric(l, engine, object);
+    };
+
+    // we can safely cast to a QV4::Object here. If object is something else,
+    // the internal class won't match
+    Heap::Object *o = static_cast<Heap::Object *>(object.heapObject());
+    if (!o || o->internalClass != l->qobjectLookup.qmlTypeIc)
+        return revertLookup();
+
+    Heap::QQmlTypeWrapper *This = static_cast<Heap::QQmlTypeWrapper *>(o);
+
+    QQmlType type = This->type();
+    if (!type.isValid())
+        return revertLookup();
+
+    if (!type.isQObjectSingleton() && !type.isCompositeSingleton())
+        return revertLookup();
+
+    QQmlEnginePrivate *e = QQmlEnginePrivate::get(engine->qmlEngine());
+    QObject *qobjectSingleton = e->singletonInstance<QObject *>(type);
+    Q_ASSERT(qobjectSingleton);
+
+    Scope scope(engine);
+    ScopedValue obj(scope, QV4::QObjectWrapper::wrap(engine, qobjectSingleton));
+    return QObjectWrapper::lookupGetterImpl(l, engine, obj, /*useOriginalProperty*/ true, revertLookup);
+}
+
 void Heap::QQmlScopedEnumWrapper::destroy()
 {
     QQmlType::derefHandle(typePrivate);