Prepare for QQmlPropertyCache to become available in QJSEngine

The cache is seemingly tied to QQmlEngine, but it isn't. A lot of
times a QQmlEngine parameter is unnecessarily dragged around and the
engine member is option as well as it turns out.

Change-Id: Iffd2a5046e9785249689ebfcbc8a0ad509f76aea
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

5 files changed, 29 insertions, 39 deletions

diff --git a/src/qml/compiler/qqmltypecompiler.cpp b/src/qml/compiler/qqmltypecompiler.cpp
index 7f399f0879..98c86c6a85 100644
--- a/src/qml/compiler/qqmltypecompiler.cpp
+++ b/src/qml/compiler/qqmltypecompiler.cpp
@@ -559,8 +559,7 @@ bool QQmlPropertyCacheCreator::ensureMetaObject(int objectIndex)
 
 bool QQmlPropertyCacheCreator::createMetaObject(int objectIndex, const QmlIR::Object *obj, QQmlPropertyCache *baseTypeCache)
 {
-    QQmlPropertyCache *cache = baseTypeCache->copyAndReserve(QQmlEnginePrivate::get(enginePrivate),
-                                                             obj->propertyCount(),
+    QQmlPropertyCache *cache = baseTypeCache->copyAndReserve(obj->propertyCount(),
                                                              obj->functionCount() + obj->propertyCount() + obj->signalCount(),
                                                              obj->signalCount() + obj->propertyCount());
     propertyCaches[objectIndex] = cache;
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index 22cf73c51d..f9de7adc93 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -2053,7 +2053,7 @@ QQmlPropertyCache *QQmlEnginePrivate::createCache(const QMetaObject *mo)
         return rv;
     } else {
         QQmlPropertyCache *super = cache(mo->superClass());
-        QQmlPropertyCache *rv = super->copyAndAppend(q, mo);
+        QQmlPropertyCache *rv = super->copyAndAppend(mo);
         propertyCache.insert(mo, rv);
         return rv;
     }
diff --git a/src/qml/qml/qqmlopenmetaobject.cpp b/src/qml/qml/qqmlopenmetaobject.cpp
index f4d050a1d7..9715fdc85d 100644
--- a/src/qml/qml/qqmlopenmetaobject.cpp
+++ b/src/qml/qml/qqmlopenmetaobject.cpp
@@ -119,7 +119,7 @@ int QQmlOpenMetaObjectType::createProperty(const QByteArray &name)
         QQmlOpenMetaObject *omo = *it;
         *static_cast<QMetaObject *>(omo) = *d->mem;
         if (d->cache)
-            d->cache->update(d->engine, omo);
+            d->cache->update(omo);
         ++it;
     }
 
diff --git a/src/qml/qml/qqmlpropertycache.cpp b/src/qml/qml/qqmlpropertycache.cpp
index 9191f26a28..363fce4375 100644
--- a/src/qml/qml/qqmlpropertycache.cpp
+++ b/src/qml/qml/qqmlpropertycache.cpp
@@ -140,10 +140,8 @@ QQmlPropertyData::flagsForProperty(const QMetaProperty &p, QQmlEngine *engine)
     return fastFlagsForProperty(p) | flagsForPropertyType(p.userType(), engine);
 }
 
-void QQmlPropertyData::lazyLoad(const QMetaProperty &p, QQmlEngine *engine)
+void QQmlPropertyData::lazyLoad(const QMetaProperty &p)
 {
-    Q_UNUSED(engine);
-
     coreIndex = p.propertyIndex();
     notifyIndex = QMetaObjectPrivate::signalIndex(p.notifySignal());
     Q_ASSERT(p.revision() <= Q_INT16_MAX);
@@ -252,7 +250,7 @@ QQmlPropertyCache::QQmlPropertyCache(QQmlEngine *e, const QMetaObject *metaObjec
     Q_ASSERT(engine);
     Q_ASSERT(metaObject);
 
-    update(engine, metaObject);
+    update(metaObject);
 }
 
 QQmlPropertyCache::~QQmlPropertyCache()
@@ -281,7 +279,6 @@ QQmlPropertyCache::~QQmlPropertyCache()
 
 void QQmlPropertyCache::destroy()
 {
-    Q_ASSERT(engine);
     delete this;
 }
 
@@ -313,7 +310,7 @@ QQmlPropertyCache *QQmlPropertyCache::copy()
     return copy(0);
 }
 
-QQmlPropertyCache *QQmlPropertyCache::copyAndReserve(QQmlEngine *, int propertyCount, int methodCount,
+QQmlPropertyCache *QQmlPropertyCache::copyAndReserve(int propertyCount, int methodCount,
                                                      int signalCount)
 {
     QQmlPropertyCache *rv = copy(propertyCount + methodCount + signalCount);
@@ -548,16 +545,16 @@ const QMetaObject *QQmlPropertyCache::firstCppMetaObject() const
 }
 
 QQmlPropertyCache *
-QQmlPropertyCache::copyAndAppend(QQmlEngine *engine, const QMetaObject *metaObject,
+QQmlPropertyCache::copyAndAppend(const QMetaObject *metaObject,
                                          QQmlPropertyData::Flag propertyFlags,
                                          QQmlPropertyData::Flag methodFlags,
                                          QQmlPropertyData::Flag signalFlags)
 {
-    return copyAndAppend(engine, metaObject, -1, propertyFlags, methodFlags, signalFlags);
+    return copyAndAppend(metaObject, -1, propertyFlags, methodFlags, signalFlags);
 }
 
 QQmlPropertyCache *
-QQmlPropertyCache::copyAndAppend(QQmlEngine *engine, const QMetaObject *metaObject,
+QQmlPropertyCache::copyAndAppend(const QMetaObject *metaObject,
                                          int revision,
                                          QQmlPropertyData::Flag propertyFlags,
                                          QQmlPropertyData::Flag methodFlags,
@@ -572,12 +569,12 @@ QQmlPropertyCache::copyAndAppend(QQmlEngine *engine, const QMetaObject *metaObje
                                          QMetaObjectPrivate::get(metaObject)->signalCount +
                                          QMetaObjectPrivate::get(metaObject)->propertyCount);
 
-    rv->append(engine, metaObject, revision, propertyFlags, methodFlags, signalFlags);
+    rv->append(metaObject, revision, propertyFlags, methodFlags, signalFlags);
 
     return rv;
 }
 
-void QQmlPropertyCache::append(QQmlEngine *engine, const QMetaObject *metaObject,
+void QQmlPropertyCache::append(const QMetaObject *metaObject,
                                        int revision,
                                        QQmlPropertyData::Flag propertyFlags,
                                        QQmlPropertyData::Flag methodFlags,
@@ -747,7 +744,7 @@ void QQmlPropertyCache::append(QQmlEngine *engine, const QMetaObject *metaObject
 
         QQmlPropertyData *data = &propertyIndexCache[ii - propertyIndexCacheStart];
 
-        data->lazyLoad(p, engine);
+        data->lazyLoad(p);
         data->flags |= propertyFlags;
 
         if (!dynamicMetaObject)
@@ -827,19 +824,18 @@ void QQmlPropertyCache::resolve(QQmlPropertyData *data) const
     data->flags &= ~QQmlPropertyData::NotFullyResolved;
 }
 
-void QQmlPropertyCache::updateRecur(QQmlEngine *engine, const QMetaObject *metaObject)
+void QQmlPropertyCache::updateRecur(const QMetaObject *metaObject)
 {
     if (!metaObject)
         return;
 
-    updateRecur(engine, metaObject->superClass());
+    updateRecur(metaObject->superClass());
 
-    append(engine, metaObject, -1);
+    append(metaObject, -1);
 }
 
-void QQmlPropertyCache::update(QQmlEngine *engine, const QMetaObject *metaObject)
+void QQmlPropertyCache::update(const QMetaObject *metaObject)
 {
-    Q_ASSERT(engine);
     Q_ASSERT(metaObject);
     Q_ASSERT(stringCache.isEmpty());
 
@@ -857,14 +853,14 @@ void QQmlPropertyCache::update(QQmlEngine *engine, const QMetaObject *metaObject
     // cached in a parent cache.
     stringCache.reserve(pc + mc + sc);
 
-    updateRecur(engine,metaObject);
+    updateRecur(metaObject);
 }
 
 /*! \internal
     invalidates and updates the PropertyCache if the QMetaObject has changed.
     This function is used in the tooling to update dynamic properties.
 */
-void QQmlPropertyCache::invalidate(QQmlEngine *engine, const QMetaObject *metaObject)
+void QQmlPropertyCache::invalidate(const QMetaObject *metaObject)
 {
     stringCache.clear();
     propertyIndexCache.clear();
@@ -884,12 +880,12 @@ void QQmlPropertyCache::invalidate(QQmlEngine *engine, const QMetaObject *metaOb
         methodIndexCacheStart = parent()->methodIndexCache.count() + parent()->methodIndexCacheStart;
         signalHandlerIndexCacheStart = parent()->signalHandlerIndexCache.count() + parent()->signalHandlerIndexCacheStart;
         stringCache.linkAndReserve(parent()->stringCache, reserve);
-        append(engine, metaObject, -1);
+        append(metaObject, -1);
     } else {
         propertyIndexCacheStart = 0;
         methodIndexCacheStart = 0;
         signalHandlerIndexCacheStart = 0;
-        update(engine, metaObject);
+        update(metaObject);
     }
 }
 
diff --git a/src/qml/qml/qqmlpropertycache_p.h b/src/qml/qml/qqmlpropertycache_p.h
index b34a5ded90..d3ea336885 100644
--- a/src/qml/qml/qqmlpropertycache_p.h
+++ b/src/qml/qml/qqmlpropertycache_p.h
@@ -233,7 +233,7 @@ public:
 
 private:
     friend class QQmlPropertyCache;
-    void lazyLoad(const QMetaProperty &, QQmlEngine *engine = 0);
+    void lazyLoad(const QMetaProperty &);
     void lazyLoad(const QMetaMethod &);
     bool notFullyResolved() const { return flags & NotFullyResolved; }
 };
@@ -246,21 +246,21 @@ public:
     QQmlPropertyCache(QQmlEngine *, const QMetaObject *);
     virtual ~QQmlPropertyCache();
 
-    void update(QQmlEngine *, const QMetaObject *);
-    void invalidate(QQmlEngine *, const QMetaObject *);
+    void update(const QMetaObject *);
+    void invalidate(const QMetaObject *);
 
     QQmlPropertyCache *copy();
 
-    QQmlPropertyCache *copyAndAppend(QQmlEngine *, const QMetaObject *,
+    QQmlPropertyCache *copyAndAppend(const QMetaObject *,
                 QQmlPropertyData::Flag propertyFlags = QQmlPropertyData::NoFlags,
                 QQmlPropertyData::Flag methodFlags = QQmlPropertyData::NoFlags,
                 QQmlPropertyData::Flag signalFlags = QQmlPropertyData::NoFlags);
-    QQmlPropertyCache *copyAndAppend(QQmlEngine *, const QMetaObject *, int revision,
+    QQmlPropertyCache *copyAndAppend(const QMetaObject *, int revision,
                 QQmlPropertyData::Flag propertyFlags = QQmlPropertyData::NoFlags,
                 QQmlPropertyData::Flag methodFlags = QQmlPropertyData::NoFlags,
                 QQmlPropertyData::Flag signalFlags = QQmlPropertyData::NoFlags);
 
-    QQmlPropertyCache *copyAndReserve(QQmlEngine *, int propertyCount,
+    QQmlPropertyCache *copyAndReserve(int propertyCount,
                                       int methodCount, int signalCount);
     void appendProperty(const QString &,
                         quint32 flags, int coreIndex, int propType, int notifyIndex);
@@ -300,7 +300,6 @@ public:
     inline QQmlPropertyData *overrideData(QQmlPropertyData *) const;
     inline bool isAllowedInRevision(QQmlPropertyData *) const;
 
-    inline QQmlEngine *qmlEngine() const;
     static QQmlPropertyData *property(QQmlEngine *, QObject *, const QString &,
                                               QQmlContextData *, QQmlPropertyData &);
     static QQmlPropertyData *property(QQmlEngine *, QObject *, const QV4::String *,
@@ -340,7 +339,7 @@ private:
 
     inline QQmlPropertyCache *copy(int reserve);
 
-    void append(QQmlEngine *, const QMetaObject *, int revision,
+    void append(const QMetaObject *, int revision,
                 QQmlPropertyData::Flag propertyFlags = QQmlPropertyData::NoFlags,
                 QQmlPropertyData::Flag methodFlags = QQmlPropertyData::NoFlags,
                 QQmlPropertyData::Flag signalFlags = QQmlPropertyData::NoFlags);
@@ -359,7 +358,7 @@ private:
     QQmlPropertyData *ensureResolved(QQmlPropertyData*) const;
 
     void resolve(QQmlPropertyData *) const;
-    void updateRecur(QQmlEngine *, const QMetaObject *);
+    void updateRecur(const QMetaObject *);
 
     template<typename K>
     QQmlPropertyData *findNamedProperty(const K &key)
@@ -375,6 +374,7 @@ private:
         _hasPropertyOverrides |= isOverride;
     }
 
+    // Optional! Only used for calling flagsForPropertyType, in which it is also optional.
     QQmlEngine *engine;
 
     QQmlPropertyCache *_parent;
@@ -509,11 +509,6 @@ bool QQmlPropertyCache::isAllowedInRevision(QQmlPropertyData *data) const
            (allowedRevisionCache[data->metaObjectOffset] >= data->revision);
 }
 
-QQmlEngine *QQmlPropertyCache::qmlEngine() const
-{
-    return engine;
-}
-
 int QQmlPropertyCache::propertyCount() const
 {
     return propertyIndexCacheStart + propertyIndexCache.count();