Get rid of QQmlVMEMetaData

It is unused now and we can remove it as well as its QByteArray based storage.
The non-emptyness of the meta-data QByteArray was also used to indicate whether
it is necessary to create a VME meta-object when instantiating an object. This
bit is now folded into the flag of the QFlagPointer storing the property
caches.

Change-Id: I3c3604c61ff16a4e76912e68b1c19afdb0f2bd9d
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>

9 files changed, 60 insertions, 95 deletions

diff --git a/src/qml/compiler/qqmltypecompiler.cpp b/src/qml/compiler/qqmltypecompiler.cpp
index c984d7a1c3..5f405cdcb8 100644
--- a/src/qml/compiler/qqmltypecompiler.cpp
+++ b/src/qml/compiler/qqmltypecompiler.cpp
@@ -137,7 +137,6 @@ bool QQmlTypeCompiler::compile()
             customParsers.insert(it.key(), customParser);
     }
 
-    compiledData->metaObjects.reserve(document->objects.count());
     compiledData->propertyCaches.reserve(document->objects.count());
 
     {
@@ -336,32 +335,21 @@ int QQmlTypeCompiler::rootObjectIndex() const
     return document->indexOfRootObject;
 }
 
-void QQmlTypeCompiler::setPropertyCaches(const QVector<QQmlPropertyCache *> &caches)
+void QQmlTypeCompiler::setPropertyCaches(const QQmlPropertyCacheVector &caches)
 {
     compiledData->propertyCaches = caches;
     Q_ASSERT(caches.count() >= document->indexOfRootObject);
     if (compiledData->rootPropertyCache)
         compiledData->rootPropertyCache->release();
-    compiledData->rootPropertyCache = caches.at(document->indexOfRootObject);
+    compiledData->rootPropertyCache = caches.at(document->indexOfRootObject).data();
     compiledData->rootPropertyCache->addref();
 }
 
-const QVector<QQmlPropertyCache *> &QQmlTypeCompiler::propertyCaches() const
+const QQmlPropertyCacheVector &QQmlTypeCompiler::propertyCaches() const
 {
     return compiledData->propertyCaches;
 }
 
-void QQmlTypeCompiler::setVMEMetaObjects(const QVector<QByteArray> &metaObjects)
-{
-    Q_ASSERT(compiledData->metaObjects.isEmpty());
-    compiledData->metaObjects = metaObjects;
-}
-
-QVector<QByteArray> *QQmlTypeCompiler::vmeMetaObjects() const
-{
-    return &compiledData->metaObjects;
-}
-
 QHash<int, int> *QQmlTypeCompiler::objectIndexToIdForRoot()
 {
     return &compiledData->objectIndexToIdForRoot;
@@ -435,7 +423,7 @@ QQmlPropertyCacheCreator::QQmlPropertyCacheCreator(QQmlTypeCompiler *typeCompile
 QQmlPropertyCacheCreator::~QQmlPropertyCacheCreator()
 {
     for (int i = 0; i < propertyCaches.count(); ++i)
-        if (QQmlPropertyCache *cache = propertyCaches.at(i))
+        if (QQmlPropertyCache *cache = propertyCaches.at(i).data())
             cache->release();
     propertyCaches.clear();
 }
@@ -443,12 +431,10 @@ QQmlPropertyCacheCreator::~QQmlPropertyCacheCreator()
 bool QQmlPropertyCacheCreator::buildMetaObjects()
 {
     propertyCaches.resize(qmlObjects.count());
-    vmeMetaObjects.resize(qmlObjects.count());
 
     if (!buildMetaObjectRecursively(compiler->rootObjectIndex(), /*referencing object*/-1, /*instantiating binding*/0))
         return false;
 
-    compiler->setVMEMetaObjects(vmeMetaObjects);
     compiler->setPropertyCaches(propertyCaches);
     propertyCaches.clear();
 
@@ -463,7 +449,7 @@ bool QQmlPropertyCacheCreator::buildMetaObjectRecursively(int objectIndex, int r
     QQmlPropertyData *instantiatingProperty = 0;
     if (instantiatingBinding && instantiatingBinding->type == QV4::CompiledData::Binding::Type_GroupProperty) {
         Q_ASSERT(referencingObjectIndex >= 0);
-        QQmlPropertyCache *parentCache = propertyCaches.at(referencingObjectIndex);
+        QQmlPropertyCache *parentCache = propertyCaches.at(referencingObjectIndex).data();
         Q_ASSERT(parentCache);
         Q_ASSERT(instantiatingBinding->propertyNameIndex != 0);
 
@@ -494,7 +480,7 @@ bool QQmlPropertyCacheCreator::buildMetaObjectRecursively(int objectIndex, int r
                 // because interceptors can't go to the shared value type instances.
                 if (instantiatingProperty && QQmlValueTypeFactory::isValueType(instantiatingProperty->propType)) {
                     needVMEMetaObject = false;
-                    if (!ensureMetaObject(referencingObjectIndex))
+                    if (!ensureVMEMetaObject(referencingObjectIndex))
                         return false;
                 }
                 break;
@@ -557,12 +543,14 @@ bool QQmlPropertyCacheCreator::buildMetaObjectRecursively(int objectIndex, int r
             if (!createMetaObject(objectIndex, obj, baseTypeCache))
                 return false;
         } else {
+            if (QQmlPropertyCache *oldCache = propertyCaches.at(objectIndex).data())
+                oldCache->release();
             propertyCaches[objectIndex] = baseTypeCache;
             baseTypeCache->addref();
         }
     }
 
-    if (propertyCaches.at(objectIndex)) {
+    if (propertyCaches.at(objectIndex).data()) {
         for (const QmlIR::Binding *binding = obj->firstBinding(); binding; binding = binding->next)
             if (binding->type >= QV4::CompiledData::Binding::Type_Object) {
                 if (!buildMetaObjectRecursively(binding->value.objectIndex, objectIndex, binding))
@@ -573,9 +561,10 @@ bool QQmlPropertyCacheCreator::buildMetaObjectRecursively(int objectIndex, int r
     return true;
 }
 
-bool QQmlPropertyCacheCreator::ensureMetaObject(int objectIndex)
+bool QQmlPropertyCacheCreator::ensureVMEMetaObject(int objectIndex)
 {
-    if (!vmeMetaObjects.at(objectIndex).isEmpty())
+    const bool willCreateVMEMetaObject = propertyCaches.at(objectIndex).flag();
+    if (willCreateVMEMetaObject)
         return true;
     const QmlIR::Object *obj = qmlObjects.at(objectIndex);
     QQmlCompiledData::TypeReference *typeRef = resolvedTypes->value(obj->inheritedTypeNameIndex);
@@ -589,7 +578,12 @@ bool QQmlPropertyCacheCreator::createMetaObject(int objectIndex, const QmlIR::Ob
     QQmlPropertyCache *cache = baseTypeCache->copyAndReserve(obj->propertyCount() + obj->aliasCount(),
                                                              obj->functionCount() + obj->propertyCount() + obj->aliasCount() + obj->signalCount(),
                                                              obj->signalCount() + obj->propertyCount() + obj->aliasCount());
+
+    if (QQmlPropertyCache *oldCache = propertyCaches.at(objectIndex).data())
+        oldCache->release();
     propertyCaches[objectIndex] = cache;
+    // Indicate that this object also needs a VME meta-object at run-time
+    propertyCaches[objectIndex].setFlag();
 
     struct TypeData {
         QV4::CompiledData::Property::Type dtype;
@@ -659,8 +653,6 @@ bool QQmlPropertyCacheCreator::createMetaObject(int objectIndex, const QmlIR::Ob
             COMPILE_EXCEPTION(a, tr("Cannot override FINAL property"));
     }
 
-    vmeMetaObjects[objectIndex] = QByteArray(sizeof(QQmlVMEMetaData), 0);
-
     int effectivePropertyIndex = cache->propertyIndexCacheStart;
     int effectiveMethodIndex = cache->methodIndexCacheStart;
 
@@ -876,7 +868,7 @@ bool SignalHandlerConverter::convertSignalHandlerExpressionsToFunctionDeclaratio
 {
     for (int objectIndex = 0; objectIndex < qmlObjects.count(); ++objectIndex) {
         const QmlIR::Object * const obj = qmlObjects.at(objectIndex);
-        QQmlPropertyCache *cache = propertyCaches.at(objectIndex);
+        QQmlPropertyCache *cache = propertyCaches.at(objectIndex).data();
         if (!cache)
             continue;
         if (QQmlCustomParser *customParser = customParsers.value(obj->inheritedTypeNameIndex)) {
@@ -1084,7 +1076,7 @@ QQmlEnumTypeResolver::QQmlEnumTypeResolver(QQmlTypeCompiler *typeCompiler)
 bool QQmlEnumTypeResolver::resolveEnumBindings()
 {
     for (int i = 0; i < qmlObjects.count(); ++i) {
-        QQmlPropertyCache *propertyCache = propertyCaches.at(i);
+        QQmlPropertyCache *propertyCache = propertyCaches.at(i).data();
         if (!propertyCache)
             continue;
         const QmlIR::Object *obj = qmlObjects.at(i);
@@ -1270,7 +1262,7 @@ QQmlAliasAnnotator::QQmlAliasAnnotator(QQmlTypeCompiler *typeCompiler)
 void QQmlAliasAnnotator::annotateBindingsToAliases()
 {
     for (int i = 0; i < qmlObjects.count(); ++i) {
-        QQmlPropertyCache *propertyCache = propertyCaches.at(i);
+        QQmlPropertyCache *propertyCache = propertyCaches.at(i).data();
         if (!propertyCache)
             continue;
 
@@ -1302,7 +1294,7 @@ void QQmlScriptStringScanner::scan()
 {
     const int scriptStringMetaType = qMetaTypeId<QQmlScriptString>();
     for (int i = 0; i < qmlObjects.count(); ++i) {
-        QQmlPropertyCache *propertyCache = propertyCaches.at(i);
+        QQmlPropertyCache *propertyCache = propertyCaches.at(i).data();
         if (!propertyCache)
             continue;
 
@@ -1339,7 +1331,6 @@ QQmlComponentAndAliasResolver::QQmlComponentAndAliasResolver(QQmlTypeCompiler *t
     , _objectIndexToIdInScope(0)
     , resolvedTypes(typeCompiler->resolvedTypes())
     , propertyCaches(typeCompiler->propertyCaches())
-    , vmeMetaObjectData(typeCompiler->vmeMetaObjects())
     , objectIndexToIdForRoot(typeCompiler->objectIndexToIdForRoot())
     , objectIndexToIdPerComponent(typeCompiler->objectIndexToIdPerComponent())
 {
@@ -1434,7 +1425,7 @@ bool QQmlComponentAndAliasResolver::resolve()
     const int objCountWithoutSynthesizedComponents = qmlObjects->count();
     for (int i = 0; i < objCountWithoutSynthesizedComponents; ++i) {
         const QmlIR::Object *obj = qmlObjects->at(i);
-        QQmlPropertyCache *cache = propertyCaches.at(i);
+        QQmlPropertyCache *cache = propertyCaches.at(i).data();
         if (obj->inheritedTypeNameIndex == 0 && !cache)
             continue;
 
@@ -1552,7 +1543,7 @@ bool QQmlComponentAndAliasResolver::resolveAliases()
     foreach (int objectIndex, _objectsWithAliases) {
         const QmlIR::Object *obj = qmlObjects->at(objectIndex);
 
-        QQmlPropertyCache *propertyCache = propertyCaches.at(objectIndex);
+        QQmlPropertyCache *propertyCache = propertyCaches.at(objectIndex).data();
         Q_ASSERT(propertyCache);
 
         int effectiveSignalIndex = propertyCache->signalHandlerIndexCacheStart + propertyCache->propertyIndexCache.count();
@@ -1603,7 +1594,7 @@ bool QQmlComponentAndAliasResolver::resolveAliases()
                 alias->flags |= QV4::CompiledData::Alias::AliasPointsToPointerObject;
                 propertyFlags |= QQmlPropertyData::IsQObjectDerived;
             } else {
-                QQmlPropertyCache *targetCache = propertyCaches.at(targetObjectIndex);
+                QQmlPropertyCache *targetCache = propertyCaches.at(targetObjectIndex).data();
                 Q_ASSERT(targetCache);
                 QmlIR::PropertyResolver resolver(targetCache);
 
@@ -1740,7 +1731,7 @@ bool QQmlPropertyValidator::validateObject(int objectIndex, const QV4::CompiledD
         return validateObject(componentBinding->value.objectIndex, componentBinding);
     }
 
-    QQmlPropertyCache *propertyCache = propertyCaches.at(objectIndex);
+    QQmlPropertyCache *propertyCache = propertyCaches.at(objectIndex).data();
     if (!propertyCache)
         return true;
 
@@ -2334,7 +2325,7 @@ bool QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *property, co
     } else if (property->isQList()) {
         const int listType = enginePrivate->listType(property->propType);
         if (!QQmlMetaType::isInterface(listType)) {
-            QQmlPropertyCache *source = propertyCaches.at(binding->value.objectIndex);
+            QQmlPropertyCache *source = propertyCaches.at(binding->value.objectIndex).data();
             if (!canCoerce(listType, source)) {
                 recordError(binding->valueLocation, tr("Cannot assign object to list property \"%1\"").arg(propertyName));
                 return false;
@@ -2361,7 +2352,7 @@ bool QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *property, co
         bool isAssignable = false;
         // Determine isAssignable value
         if (propertyMetaObject) {
-            QQmlPropertyCache *c = propertyCaches.at(binding->value.objectIndex);
+            QQmlPropertyCache *c = propertyCaches.at(binding->value.objectIndex).data();
             while (c && !isAssignable) {
                 isAssignable |= c == propertyMetaObject;
                 c = c->parent();
@@ -2421,7 +2412,7 @@ bool QQmlJSCodeGenerator::compileComponent(int contextObject, const QHash<int, i
             const QmlIR::Object *obj = qmlObjects.at(objectIndex);
             m.name = stringAt(obj->idIndex);
             m.idIndex = idIt.value();
-            m.type = propertyCaches.at(objectIndex);
+            m.type = propertyCaches.at(objectIndex).data();
 
             QQmlCompiledData::TypeReference *tref = resolvedTypes.value(obj->inheritedTypeNameIndex);
             if (tref && tref->isFullyDynamicType)
@@ -2430,7 +2421,7 @@ bool QQmlJSCodeGenerator::compileComponent(int contextObject, const QHash<int, i
             idMapping << m;
         }
     }
-    v4CodeGen->beginContextScope(idMapping, propertyCaches.at(contextObject));
+    v4CodeGen->beginContextScope(idMapping, propertyCaches.at(contextObject).data());
 
     if (!compileJavaScriptCodeInObjectsRecursively(contextObject, contextObject))
         return false;
@@ -2445,7 +2436,7 @@ bool QQmlJSCodeGenerator::compileJavaScriptCodeInObjectsRecursively(int objectIn
 
     QmlIR::Object *object = qmlObjects.at(objectIndex);
     if (object->functionsAndExpressions->count > 0) {
-        QQmlPropertyCache *scopeObject = propertyCaches.at(scopeObjectIndex);
+        QQmlPropertyCache *scopeObject = propertyCaches.at(scopeObjectIndex).data();
         v4CodeGen->beginObjectScope(scopeObject);
 
         QList<QmlIR::CompiledFunctionOrExpression> functionsToCompile;
@@ -2498,7 +2489,7 @@ void QQmlDefaultPropertyMerger::mergeDefaultProperties()
 
 void QQmlDefaultPropertyMerger::mergeDefaultProperties(int objectIndex)
 {
-    QQmlPropertyCache *propertyCache = propertyCaches.at(objectIndex);
+    QQmlPropertyCache *propertyCache = propertyCaches.at(objectIndex).data();
     if (!propertyCache)
         return;
 
diff --git a/src/qml/compiler/qqmltypecompiler_p.h b/src/qml/compiler/qqmltypecompiler_p.h
index 273ba01a88..968902dae1 100644
--- a/src/qml/compiler/qqmltypecompiler_p.h
+++ b/src/qml/compiler/qqmltypecompiler_p.h
@@ -99,10 +99,8 @@ public:
     QHash<int, QQmlCompiledData::TypeReference *> *resolvedTypes();
     QList<QmlIR::Object*> *qmlObjects();
     int rootObjectIndex() const;
-    void setPropertyCaches(const QVector<QQmlPropertyCache *> &caches);
-    const QVector<QQmlPropertyCache *> &propertyCaches() const;
-    void setVMEMetaObjects(const QVector<QByteArray> &metaObjects);
-    QVector<QByteArray> *vmeMetaObjects() const;
+    void setPropertyCaches(const QQmlPropertyCacheVector &caches);
+    const QQmlPropertyCacheVector &propertyCaches() const;
     QHash<int, int> *objectIndexToIdForRoot();
     QHash<int, QHash<int, int> > *objectIndexToIdPerComponent();
     QHash<int, QBitArray> *customParserBindings();
@@ -149,15 +147,14 @@ public:
     bool buildMetaObjects();
 protected:
     bool buildMetaObjectRecursively(int objectIndex, int referencingObjectIndex, const QV4::CompiledData::Binding *instantiatingBinding);
-    bool ensureMetaObject(int objectIndex);
+    bool ensureVMEMetaObject(int objectIndex);
     bool createMetaObject(int objectIndex, const QmlIR::Object *obj, QQmlPropertyCache *baseTypeCache);
 
     QQmlEnginePrivate *enginePrivate;
     const QList<QmlIR::Object*> &qmlObjects;
     const QQmlImports *imports;
     QHash<int, QQmlCompiledData::TypeReference*> *resolvedTypes;
-    QVector<QByteArray> vmeMetaObjects;
-    QVector<QQmlPropertyCache*> propertyCaches;
+    QQmlPropertyCacheVector propertyCaches;
 };
 
 // "Converts" signal expressions to full-fleged function declarations with
@@ -181,7 +178,7 @@ private:
     const QHash<int, QQmlCustomParser*> &customParsers;
     const QHash<int, QQmlCompiledData::TypeReference*> &resolvedTypes;
     const QSet<QString> &illegalNames;
-    const QVector<QQmlPropertyCache*> &propertyCaches;
+    const QQmlPropertyCacheVector &propertyCaches;
 };
 
 // ### This will go away when the codegen resolves all enums to constant expressions
@@ -208,7 +205,7 @@ private:
 
 
     const QList<QmlIR::Object*> &qmlObjects;
-    const QVector<QQmlPropertyCache *> propertyCaches;
+    const QQmlPropertyCacheVector propertyCaches;
     const QQmlImports *imports;
     QHash<int, QQmlCompiledData::TypeReference *> *resolvedTypes;
 };
@@ -236,7 +233,7 @@ public:
     void annotateBindingsToAliases();
 private:
     const QList<QmlIR::Object*> &qmlObjects;
-    const QVector<QQmlPropertyCache *> propertyCaches;
+    const QQmlPropertyCacheVector propertyCaches;
 };
 
 class QQmlScriptStringScanner : public QQmlCompilePass
@@ -248,7 +245,7 @@ public:
 
 private:
     const QList<QmlIR::Object*> &qmlObjects;
-    const QVector<QQmlPropertyCache *> propertyCaches;
+    const QQmlPropertyCacheVector propertyCaches;
 };
 
 class QQmlComponentAndAliasResolver : public QQmlCompilePass
@@ -282,8 +279,7 @@ protected:
     QList<int> _objectsWithAliases;
 
     QHash<int, QQmlCompiledData::TypeReference*> *resolvedTypes;
-    QVector<QQmlPropertyCache *> propertyCaches;
-    QVector<QByteArray> *vmeMetaObjectData;
+    QQmlPropertyCacheVector propertyCaches;
     QHash<int, int> *objectIndexToIdForRoot;
     QHash<int, QHash<int, int> > *objectIndexToIdPerComponent;
 };
@@ -312,7 +308,7 @@ private:
     const QV4::CompiledData::Unit *qmlUnit;
     const QHash<int, QQmlCompiledData::TypeReference*> &resolvedTypes;
     const QHash<int, QQmlCustomParser*> &customParsers;
-    const QVector<QQmlPropertyCache *> &propertyCaches;
+    const QQmlPropertyCacheVector &propertyCaches;
     const QHash<int, QHash<int, int> > objectIndexToIdPerComponent;
     QHash<int, QBitArray> *customParserBindingsPerObject;
 
@@ -340,7 +336,7 @@ private:
     const QHash<int, QQmlCompiledData::TypeReference*> &resolvedTypes;
     const QHash<int, QQmlCustomParser*> &customParsers;
     const QList<QmlIR::Object*> &qmlObjects;
-    const QVector<QQmlPropertyCache *> &propertyCaches;
+    const QQmlPropertyCacheVector &propertyCaches;
     QmlIR::JSCodeGen * const v4CodeGen;
 };
 
@@ -355,7 +351,7 @@ private:
     void mergeDefaultProperties(int objectIndex);
 
     const QList<QmlIR::Object*> &qmlObjects;
-    const QVector<QQmlPropertyCache*> &propertyCaches;
+    const QQmlPropertyCacheVector &propertyCaches;
 };
 
 class QQmlJavaScriptBindingExpressionSimplificationPass : public QQmlCompilePass, public QV4::IR::StmtVisitor
diff --git a/src/qml/qml/qqmlcompileddata.cpp b/src/qml/qml/qqmlcompileddata.cpp
index 28d599a593..0b44972491 100644
--- a/src/qml/qml/qqmlcompileddata.cpp
+++ b/src/qml/qml/qqmlcompileddata.cpp
@@ -87,7 +87,7 @@ QQmlCompiledData::~QQmlCompiledData()
     resolvedTypes.clear();
 
     for (int ii = 0; ii < propertyCaches.count(); ++ii)
-        if (propertyCaches.at(ii))
+        if (propertyCaches.at(ii).data())
             propertyCaches.at(ii)->release();
 
     for (int ii = 0; ii < scripts.count(); ++ii)
diff --git a/src/qml/qml/qqmlcompiler_p.h b/src/qml/qml/qqmlcompiler_p.h
index cbe70a7077..42b73fcaf5 100644
--- a/src/qml/qml/qqmlcompiler_p.h
+++ b/src/qml/qml/qqmlcompiler_p.h
@@ -80,6 +80,10 @@ class QQmlComponent;
 class QQmlContext;
 class QQmlContextData;
 
+// The vector is indexed by QV4::CompiledData::Object index and the flag
+// indicates whether instantiation of the object requires a VME meta-object.
+typedef QVector<QFlagPointer<QQmlPropertyCache>> QQmlPropertyCacheVector;
+
 // ### Merge with QV4::CompiledData::CompilationUnit
 class Q_AUTOTEST_EXPORT QQmlCompiledData : public QQmlRefCount, public QQmlCleanup
 {
@@ -123,8 +127,7 @@ public:
     QHash<int, TypeReference*> resolvedTypes;
 
     QQmlPropertyCache *rootPropertyCache;
-    QVector<QByteArray> metaObjects;
-    QVector<QQmlPropertyCache *> propertyCaches;
+    QQmlPropertyCacheVector propertyCaches;
     QList<QQmlScriptData *> scripts;
 
     QQmlRefPointer<QV4::CompiledData::CompilationUnit> compilationUnit;
@@ -139,7 +142,7 @@ public:
     int totalObjectCount; // Number of objects explicitly instantiated
 
     bool isComponent(int objectIndex) const { return objectIndexToIdPerComponent.contains(objectIndex); }
-    bool isCompositeType() const { return !metaObjects.at(compilationUnit->data->indexOfRootObject).isEmpty(); }
+    bool isCompositeType() const { return propertyCaches.at(compilationUnit->data->indexOfRootObject).flag(); }
 
     bool isInitialized() const { return hasEngine(); }
     void initialize(QQmlEngine *);
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index 775f8a9294..86693af3d3 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -74,7 +74,6 @@ QQmlObjectCreator::QQmlObjectCreator(QQmlContextData *parentContext, QQmlCompile
     , compiledData(compiledData)
     , resolvedTypes(compiledData->resolvedTypes)
     , propertyCaches(compiledData->propertyCaches)
-    , vmeMetaObjectData(compiledData->metaObjects)
     , activeVMEDataForRootContext(activeVMEDataForRootContext)
 {
     init(parentContext);
@@ -99,7 +98,6 @@ QQmlObjectCreator::QQmlObjectCreator(QQmlContextData *parentContext, QQmlCompile
     , compiledData(compiledData)
     , resolvedTypes(compiledData->resolvedTypes)
     , propertyCaches(compiledData->propertyCaches)
-    , vmeMetaObjectData(compiledData->metaObjects)
     , activeVMEDataForRootContext(0)
 {
     init(parentContext);
@@ -1152,7 +1150,7 @@ QObject *QQmlObjectCreator::createInstance(int index, QObject *parent, bool isCo
         return instance;
     }
 
-    QQmlRefPointer<QQmlPropertyCache> cache = propertyCaches.at(index);
+    QQmlRefPointer<QQmlPropertyCache> cache = propertyCaches.at(index).data();
     Q_ASSERT(!cache.isNull());
     if (installPropertyCache) {
         if (ddata->propertyCache)
@@ -1283,14 +1281,14 @@ bool QQmlObjectCreator::populateInstance(int index, QObject *instance, QObject *
     QV4::Scope valueScope(v4);
     QV4::ScopedValue scopeObjectProtector(valueScope);
 
-    QQmlRefPointer<QQmlPropertyCache> cache = propertyCaches.at(_compiledObjectIndex);
+    QQmlRefPointer<QQmlPropertyCache> cache = propertyCaches.at(_compiledObjectIndex).data();
 
     QQmlVMEMetaObject *vmeMetaObject = 0;
-    const QByteArray data = vmeMetaObjectData.value(_compiledObjectIndex);
-    if (!data.isEmpty()) {
+    const bool needVMEMetaObject = propertyCaches.at(_compiledObjectIndex).flag();
+    if (needVMEMetaObject) {
         Q_ASSERT(!cache.isNull());
         // install on _object
-        vmeMetaObject = new QQmlVMEMetaObject(_qobject, cache, reinterpret_cast<const QQmlVMEMetaData*>(data.constData()), compiledData->compilationUnit, _compiledObjectIndex);
+        vmeMetaObject = new QQmlVMEMetaObject(_qobject, cache, compiledData->compilationUnit, _compiledObjectIndex);
         if (_ddata->propertyCache)
             _ddata->propertyCache->release();
         _ddata->propertyCache = cache;
diff --git a/src/qml/qml/qqmlobjectcreator_p.h b/src/qml/qml/qqmlobjectcreator_p.h
index 3d743954c9..8045281cbb 100644
--- a/src/qml/qml/qqmlobjectcreator_p.h
+++ b/src/qml/qml/qqmlobjectcreator_p.h
@@ -142,8 +142,7 @@ private:
     QQmlGuardedContextData parentContext;
     QQmlContextData *context;
     const QHash<int, QQmlCompiledData::TypeReference*> &resolvedTypes;
-    const QVector<QQmlPropertyCache *> &propertyCaches;
-    const QVector<QByteArray> &vmeMetaObjectData;
+    const QQmlPropertyCacheVector &propertyCaches;
     QHash<int, int> objectIndexToId;
     QExplicitlySharedDataPointer<QQmlObjectCreatorSharedState> sharedState;
     bool topLevelCreator;
diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index 674cd075e1..8697a291e2 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -314,10 +314,9 @@ QAbstractDynamicMetaObject *QQmlInterceptorMetaObject::toDynamicMetaObject(QObje
 }
 
 QQmlVMEMetaObject::QQmlVMEMetaObject(QObject *obj,
-                                     QQmlPropertyCache *cache,
-                                     const QQmlVMEMetaData *meta, QV4::CompiledData::CompilationUnit *qmlCompilationUnit, int qmlObjectId)
+                                     QQmlPropertyCache *cache, QV4::CompiledData::CompilationUnit *qmlCompilationUnit, int qmlObjectId)
     : QQmlInterceptorMetaObject(obj, cache),
-      ctxt(QQmlData::get(obj, true)->outerContext), metaData(meta),
+      ctxt(QQmlData::get(obj, true)->outerContext),
       aliasEndpoints(0), compilationUnit(qmlCompilationUnit), compiledObject(0)
 {
     cache->addref();
diff --git a/src/qml/qml/qqmlvmemetaobject_p.h b/src/qml/qml/qqmlvmemetaobject_p.h
index d8c3b9a248..75e7ed6cb1 100644
--- a/src/qml/qml/qqmlvmemetaobject_p.h
+++ b/src/qml/qml/qqmlvmemetaobject_p.h
@@ -74,12 +74,6 @@
 
 QT_BEGIN_NAMESPACE
 
-struct QQmlVMEMetaData
-{
-    // Make sure this structure is always aligned to int
-    int dummy;
-};
-
 class QQmlVMEMetaObject;
 class QQmlVMEVariantQObjectPtr : public QQmlGuard<QObject>
 {
@@ -139,7 +133,7 @@ class QQmlVMEMetaObjectEndpoint;
 class Q_QML_PRIVATE_EXPORT QQmlVMEMetaObject : public QQmlInterceptorMetaObject
 {
 public:
-    QQmlVMEMetaObject(QObject *obj, QQmlPropertyCache *cache, const QQmlVMEMetaData *data, QV4::CompiledData::CompilationUnit *qmlCompilationUnit, int qmlObjectId);
+    QQmlVMEMetaObject(QObject *obj, QQmlPropertyCache *cache, QV4::CompiledData::CompilationUnit *qmlCompilationUnit, int qmlObjectId);
     ~QQmlVMEMetaObject();
 
     bool aliasTarget(int index, QObject **target, int *coreIndex, int *valueTypeIndex) const;
@@ -161,7 +155,6 @@ protected:
 public:
     QQmlGuardedContextData ctxt;
 
-    const QQmlVMEMetaData *metaData;
     inline int propOffset() const;
     inline int methodOffset() const;
     inline int signalOffset() const;
diff --git a/src/quick/designer/qqmldesignermetaobject.cpp b/src/quick/designer/qqmldesignermetaobject.cpp
index 63b4102b10..23a29d5831 100644
--- a/src/quick/designer/qqmldesignermetaobject.cpp
+++ b/src/quick/designer/qqmldesignermetaobject.cpp
@@ -79,20 +79,6 @@ struct MetaPropertyData {
     QVector<QPair<QVariant, bool> > m_data;
 };
 
-static QQmlVMEMetaData* fakeMetaData()
-{
-    return new QQmlVMEMetaData;
-}
-
-static const QQmlVMEMetaData* vMEMetaDataForObject(QObject *object)
-{
-    QQmlVMEMetaObject *metaObject = QQmlVMEMetaObject::get(object);
-    if (metaObject)
-        return metaObject->metaData;
-
-    return fakeMetaData();
-}
-
 static QQmlPropertyCache *cacheForObject(QObject *object, QQmlEngine *engine)
 {
     QQmlVMEMetaObject *metaObject = QQmlVMEMetaObject::get(object);
@@ -147,7 +133,7 @@ void QQmlDesignerMetaObject::init(QObject *object, QQmlEngine *engine)
 }
 
 QQmlDesignerMetaObject::QQmlDesignerMetaObject(QObject *object, QQmlEngine *engine)
-    : QQmlVMEMetaObject(object, cacheForObject(object, engine), vMEMetaDataForObject(object), /*qml compilation unit*/nullptr, /*qmlObjectId*/-1),
+    : QQmlVMEMetaObject(object, cacheForObject(object, engine), /*qml compilation unit*/nullptr, /*qmlObjectId*/-1),
       m_context(engine->contextForObject(object)),
       m_data(new MetaPropertyData),
       m_cache(0)