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

 Conflicts:
	src/qml/compiler/qqmltypecompiler.cpp
	src/qml/jsruntime/qv4qmlcontext.cpp
	src/qml/jsruntime/qv4qobjectwrapper.cpp
	src/qml/qml/qqmlcustomparser.cpp
	src/qml/qml/qqmlimport.cpp
	src/qml/qml/qqmlimport_p.h
	src/qml/qml/qqmlmetatype.cpp
	src/qml/qml/qqmlmetatype_p.h
	src/qml/qml/qqmltypenamecache.cpp
	src/qml/qml/qqmltypenamecache_p.h
	src/qml/qml/qqmltypewrapper.cpp
	src/qml/qml/qqmltypewrapper_p.h
	src/qml/qml/qqmlvmemetaobject.cpp
	src/qml/util/qqmladaptormodel.cpp

Change-Id: Ic959d03e6f9c328fb02710d9abbb0f27cddde131

7 files changed, 114 insertions, 107 deletions

diff --git a/src/qml/compiler/qqmlirbuilder.cpp b/src/qml/compiler/qqmlirbuilder.cpp
index e05c38e14a..b58920d812 100644
--- a/src/qml/compiler/qqmlirbuilder.cpp
+++ b/src/qml/compiler/qqmlirbuilder.cpp
@@ -1777,7 +1777,7 @@ enum MetaObjectResolverFlags {
 };
 
 static void initMetaObjectResolver(QV4::IR::MemberExpressionResolver *resolver, QQmlPropertyCache *metaObject);
-static void initScopedEnumResolver(QV4::IR::MemberExpressionResolver *resolver, QQmlType *qmlType, int index);
+static void initScopedEnumResolver(QV4::IR::MemberExpressionResolver *resolver, const QQmlType &qmlType, int index);
 
 static QV4::IR::DiscoveredType resolveQmlType(QQmlEnginePrivate *qmlEngine,
                                               const QV4::IR::MemberExpressionResolver *resolver,
@@ -1785,16 +1785,16 @@ static QV4::IR::DiscoveredType resolveQmlType(QQmlEnginePrivate *qmlEngine,
 {
     QV4::IR::Type result = QV4::IR::VarType;
 
-    QQmlType *type = static_cast<QQmlType*>(resolver->data);
+    QQmlType type = resolver->qmlType;
 
     if (member->name->constData()->isUpper()) {
         bool ok = false;
-        int value = type->enumValue(qmlEngine, *member->name, &ok);
+        int value = type.enumValue(qmlEngine, *member->name, &ok);
         if (ok) {
             member->setEnumValue(value);
             return QV4::IR::SInt32Type;
         } else {
-            int index = type->scopedEnumIndex(qmlEngine, *member->name, &ok);
+            int index = type.scopedEnumIndex(qmlEngine, *member->name, &ok);
             if (ok) {
                 auto newResolver = resolver->owner->New<QV4::IR::MemberExpressionResolver>();
                 newResolver->owner = resolver->owner;
@@ -1804,8 +1804,8 @@ static QV4::IR::DiscoveredType resolveQmlType(QQmlEnginePrivate *qmlEngine,
         }
     }
 
-    if (type->isCompositeSingleton()) {
-        QQmlRefPointer<QQmlTypeData> tdata = qmlEngine->typeLoader.getType(type->singletonInstanceInfo()->url);
+    if (type.isCompositeSingleton()) {
+        QQmlRefPointer<QQmlTypeData> tdata = qmlEngine->typeLoader.getType(type.singletonInstanceInfo()->url);
         Q_ASSERT(tdata);
         tdata->release(); // Decrease the reference count added from QQmlTypeLoader::getType()
         // When a singleton tries to reference itself, it may not be complete yet.
@@ -1816,8 +1816,8 @@ static QV4::IR::DiscoveredType resolveQmlType(QQmlEnginePrivate *qmlEngine,
             newResolver->flags |= AllPropertiesAreFinal;
             return newResolver->resolveMember(qmlEngine, newResolver, member);
         }
-    }  else if (type->isSingleton()) {
-        const QMetaObject *singletonMeta = type->singletonInstanceInfo()->instanceMetaObject;
+    }  else if (type.isSingleton()) {
+        const QMetaObject *singletonMeta = type.singletonInstanceInfo()->instanceMetaObject;
         if (singletonMeta) { // QJSValue-based singletons cannot be accelerated
             auto newResolver = resolver->owner->New<QV4::IR::MemberExpressionResolver>();
             newResolver->owner = resolver->owner;
@@ -1842,13 +1842,13 @@ static QV4::IR::DiscoveredType resolveQmlType(QQmlEnginePrivate *qmlEngine,
     return result;
 }
 
-static void initQmlTypeResolver(QV4::IR::MemberExpressionResolver *resolver, QQmlType *qmlType)
+static void initQmlTypeResolver(QV4::IR::MemberExpressionResolver *resolver, const QQmlType &qmlType)
 {
     Q_ASSERT(resolver);
 
     resolver->resolveMember = &resolveQmlType;
-    resolver->data = qmlType;
-    resolver->extraData = 0;
+    resolver->qmlType = qmlType;
+    resolver->typenameCache = 0;
     resolver->flags = 0;
 }
 
@@ -1857,8 +1857,8 @@ static QV4::IR::DiscoveredType resolveImportNamespace(
         QV4::IR::Member *member)
 {
     QV4::IR::Type result = QV4::IR::VarType;
-    QQmlTypeNameCache *typeNamespace = static_cast<QQmlTypeNameCache*>(resolver->extraData);
-    void *importNamespace = resolver->data;
+    QQmlTypeNameCache *typeNamespace = resolver->typenameCache;
+    const QQmlImportRef *importNamespace = resolver->import;
 
     QQmlTypeNameCache::Result r = typeNamespace->query(*member->name, importNamespace);
     if (r.isValid()) {
@@ -1866,11 +1866,11 @@ static QV4::IR::DiscoveredType resolveImportNamespace(
         if (r.scriptIndex != -1) {
             // TODO: remember the index and replace with subscript later.
             result = QV4::IR::VarType;
-        } else if (r.type) {
+        } else if (r.type.isValid()) {
             // TODO: Propagate singleton information, so that it is loaded
             // through the singleton getter in the run-time. Until then we
             // can't accelerate access :(
-            if (!r.type->isSingleton()) {
+            if (!r.type.isSingleton()) {
                 auto newResolver = resolver->owner->New<QV4::IR::MemberExpressionResolver>();
                 newResolver->owner = resolver->owner;
                 initQmlTypeResolver(newResolver, r.type);
@@ -1885,11 +1885,11 @@ static QV4::IR::DiscoveredType resolveImportNamespace(
 }
 
 static void initImportNamespaceResolver(QV4::IR::MemberExpressionResolver *resolver,
-                                        QQmlTypeNameCache *imports, const void *importNamespace)
+                                        QQmlTypeNameCache *imports, const QQmlImportRef *importNamespace)
 {
     resolver->resolveMember = &resolveImportNamespace;
-    resolver->data = const_cast<void*>(importNamespace);
-    resolver->extraData = imports;
+    resolver->import = importNamespace;
+    resolver->typenameCache = imports;
     resolver->flags = 0;
 }
 
@@ -1898,7 +1898,7 @@ static QV4::IR::DiscoveredType resolveMetaObjectProperty(
         QV4::IR::Member *member)
 {
     QV4::IR::Type result = QV4::IR::VarType;
-    QQmlPropertyCache *metaObject = static_cast<QQmlPropertyCache*>(resolver->data);
+    QQmlPropertyCache *metaObject = resolver->propertyCache;
 
     if (member->name->constData()->isUpper() && (resolver->flags & LookupsIncludeEnums)) {
         const QMetaObject *mo = metaObject->createMetaObject();
@@ -1980,7 +1980,7 @@ static void initMetaObjectResolver(QV4::IR::MemberExpressionResolver *resolver,
     Q_ASSERT(resolver);
 
     resolver->resolveMember = &resolveMetaObjectProperty;
-    resolver->data = metaObject;
+    resolver->propertyCache = metaObject;
     resolver->flags = 0;
 }
 
@@ -1991,24 +1991,23 @@ static QV4::IR::DiscoveredType resolveScopedEnum(QQmlEnginePrivate *qmlEngine,
     if (!member->name->constData()->isUpper())
         return QV4::IR::VarType;
 
-    QQmlType *type = static_cast<QQmlType*>(resolver->data);
+    QQmlType type = resolver->qmlType;
     int index = resolver->flags;
 
     bool ok = false;
-    int value = type->scopedEnumValue(qmlEngine, index, *member->name, &ok);
+    int value = type.scopedEnumValue(qmlEngine, index, *member->name, &ok);
     if (!ok)
         return QV4::IR::VarType;
     member->setEnumValue(value);
     return QV4::IR::SInt32Type;
 }
 
-static void initScopedEnumResolver(QV4::IR::MemberExpressionResolver *resolver, QQmlType *qmlType, int index)
+static void initScopedEnumResolver(QV4::IR::MemberExpressionResolver *resolver, const QQmlType &qmlType, int index)
 {
     Q_ASSERT(resolver);
 
     resolver->resolveMember = &resolveScopedEnum;
-    resolver->data = qmlType;
-    resolver->extraData = 0;
+    resolver->qmlType = qmlType;
     resolver->flags = index;
 }
 
@@ -2077,10 +2076,10 @@ QV4::IR::Expr *JSCodeGen::fallbackNameLookup(const QString &name, int line, int
             if (r.scriptIndex != -1) {
                 return _block->SUBSCRIPT(_block->TEMP(_importedScriptsTemp),
                                          _block->CONST(QV4::IR::SInt32Type, r.scriptIndex));
-            } else if (r.type) {
+            } else if (r.type.isValid()) {
                 QV4::IR::Name *typeName = _block->NAME(name, line, col);
                 // Make sure the run-time loads this through the more efficient singleton getter.
-                typeName->qmlSingleton = r.type->isCompositeSingleton();
+                typeName->qmlSingleton = r.type.isCompositeSingleton();
                 typeName->freeOfSideEffects = true;
                 QV4::IR::Temp *result = _block->TEMP(_block->newTemp());
                 _block->MOVE(result, typeName);
diff --git a/src/qml/compiler/qqmlpropertycachecreator_p.h b/src/qml/compiler/qqmlpropertycachecreator_p.h
index 5901e4e13e..b33deac045 100644
--- a/src/qml/compiler/qqmlpropertycachecreator_p.h
+++ b/src/qml/compiler/qqmlpropertycachecreator_p.h
@@ -211,12 +211,12 @@ inline QQmlPropertyCache *QQmlPropertyCacheCreator<ObjectContainer>::propertyCac
     } else if (context.instantiatingBinding && context.instantiatingBinding->isAttachedProperty()) {
         auto *typeRef = objectContainer->resolvedTypes.value(context.instantiatingBinding->propertyNameIndex);
         Q_ASSERT(typeRef);
-        QQmlType *qmltype = typeRef->type;
-        if (!qmltype) {
+        QQmlType qmltype = typeRef->type;
+        if (!qmltype.isValid()) {
             QString propertyName = stringAt(context.instantiatingBinding->propertyNameIndex);
             if (imports->resolveType(propertyName, &qmltype, 0, 0, 0)) {
-                if (qmltype->isComposite()) {
-                    QQmlTypeData *tdata = enginePrivate->typeLoader.getType(qmltype->sourceUrl());
+                if (qmltype.isComposite()) {
+                    QQmlTypeData *tdata = enginePrivate->typeLoader.getType(qmltype.sourceUrl());
                     Q_ASSERT(tdata);
                     Q_ASSERT(tdata->isComplete());
 
@@ -228,7 +228,7 @@ inline QQmlPropertyCache *QQmlPropertyCacheCreator<ObjectContainer>::propertyCac
             }
         }
 
-        const QMetaObject *attachedMo = qmltype ? qmltype->attachedPropertiesType(enginePrivate) : 0;
+        const QMetaObject *attachedMo = qmltype.attachedPropertiesType(enginePrivate);
         if (!attachedMo) {
             *error = QQmlCompileError(context.instantiatingBinding->location, QQmlPropertyCacheCreatorBase::tr("Non-existent attached object"));
             return nullptr;
@@ -410,12 +410,12 @@ inline QQmlCompileError QQmlPropertyCacheCreator<ObjectContainer>::createMetaObj
                     // lazily resolved type
                     Q_ASSERT(param->type == QV4::CompiledData::Property::Custom);
                     const QString customTypeName = stringAt(param->customTypeNameIndex);
-                    QQmlType *qmltype = 0;
+                    QQmlType qmltype;
                     if (!imports->resolveType(customTypeName, &qmltype, 0, 0, 0))
                         return QQmlCompileError(s->location, QQmlPropertyCacheCreatorBase::tr("Invalid signal parameter type: %1").arg(customTypeName));
 
-                    if (qmltype->isComposite()) {
-                        QQmlTypeData *tdata = enginePrivate->typeLoader.getType(qmltype->sourceUrl());
+                    if (qmltype.isComposite()) {
+                        QQmlTypeData *tdata = enginePrivate->typeLoader.getType(qmltype.sourceUrl());
                         Q_ASSERT(tdata);
                         Q_ASSERT(tdata->isComplete());
 
@@ -425,7 +425,7 @@ inline QQmlCompileError QQmlPropertyCacheCreator<ObjectContainer>::createMetaObj
 
                         tdata->release();
                     } else {
-                        paramTypes[i + 1] = qmltype->typeId();
+                        paramTypes[i + 1] = qmltype.typeId();
                     }
                 }
             }
@@ -490,14 +490,14 @@ inline QQmlCompileError QQmlPropertyCacheCreator<ObjectContainer>::createMetaObj
             Q_ASSERT(p->type == QV4::CompiledData::Property::CustomList ||
                      p->type == QV4::CompiledData::Property::Custom);
 
-            QQmlType *qmltype = 0;
+            QQmlType qmltype;
             if (!imports->resolveType(stringAt(p->customTypeNameIndex), &qmltype, 0, 0, 0)) {
                 return QQmlCompileError(p->location, QQmlPropertyCacheCreatorBase::tr("Invalid property type"));
             }
 
-            Q_ASSERT(qmltype);
-            if (qmltype->isComposite()) {
-                QQmlTypeData *tdata = enginePrivate->typeLoader.getType(qmltype->sourceUrl());
+            Q_ASSERT(qmltype.isValid());
+            if (qmltype.isComposite()) {
+                QQmlTypeData *tdata = enginePrivate->typeLoader.getType(qmltype.sourceUrl());
                 Q_ASSERT(tdata);
                 Q_ASSERT(tdata->isComplete());
 
@@ -512,9 +512,9 @@ inline QQmlCompileError QQmlPropertyCacheCreator<ObjectContainer>::createMetaObj
                 tdata->release();
             } else {
                 if (p->type == QV4::CompiledData::Property::Custom) {
-                    propertyType = qmltype->typeId();
+                    propertyType = qmltype.typeId();
                 } else {
-                    propertyType = qmltype->qListTypeId();
+                    propertyType = qmltype.qListTypeId();
                 }
             }
 
@@ -690,8 +690,8 @@ inline void QQmlPropertyCacheAliasCreator<ObjectContainer>::propertyDataForAlias
         auto *typeRef = objectContainer->resolvedTypes.value(targetObject.inheritedTypeNameIndex);
         Q_ASSERT(typeRef);
 
-        if (typeRef->type)
-            *type = typeRef->type->typeId();
+        if (typeRef->type.isValid())
+            *type = typeRef->type.typeId();
         else
             *type = typeRef->compilationUnit->metaTypeId;
 
diff --git a/src/qml/compiler/qqmlpropertyvalidator.cpp b/src/qml/compiler/qqmlpropertyvalidator.cpp
index 383c20239f..4ac7aad553 100644
--- a/src/qml/compiler/qqmlpropertyvalidator.cpp
+++ b/src/qml/compiler/qqmlpropertyvalidator.cpp
@@ -106,8 +106,8 @@ QVector<QQmlCompileError> QQmlPropertyValidator::validateObject(int objectIndex,
 
     QQmlCustomParser *customParser = 0;
     if (auto typeRef = resolvedTypes.value(obj->inheritedTypeNameIndex)) {
-        if (typeRef->type)
-            customParser = typeRef->type->customParser();
+        if (typeRef->type.isValid())
+            customParser = typeRef->type.customParser();
     }
 
     QList<const QV4::CompiledData::Binding*> customBindings;
@@ -178,8 +178,8 @@ QVector<QQmlCompileError> QQmlPropertyValidator::validateObject(int objectIndex,
             if (notInRevision) {
                 QString typeName = stringAt(obj->inheritedTypeNameIndex);
                 auto *objectType = resolvedTypes.value(obj->inheritedTypeNameIndex);
-                if (objectType && objectType->type) {
-                    return recordError(binding->location, tr("\"%1.%2\" is not available in %3 %4.%5.").arg(typeName).arg(name).arg(objectType->type->module()).arg(objectType->majorVersion).arg(objectType->minorVersion));
+                if (objectType && objectType->type.isValid()) {
+                    return recordError(binding->location, tr("\"%1.%2\" is not available in %3 %4.%5.").arg(typeName).arg(name).arg(objectType->type.module()).arg(objectType->majorVersion).arg(objectType->minorVersion));
                 } else {
                     return recordError(binding->location, tr("\"%1.%2\" is not available due to component versioning.").arg(typeName).arg(name));
                 }
@@ -197,7 +197,7 @@ QVector<QQmlCompileError> QQmlPropertyValidator::validateObject(int objectIndex,
             collectedBindingPropertyData[i] = pd;
 
         if (name.constData()->isUpper() && !binding->isAttachedProperty()) {
-            QQmlType *type = 0;
+            QQmlType type;
             QQmlImportNamespace *typeNamespace = 0;
             imports.resolveType(stringAt(binding->propertyNameIndex), &type, 0, 0, &typeNamespace);
             if (typeNamespace)
@@ -628,21 +628,19 @@ QQmlCompileError QQmlPropertyValidator::validateObjectBinding(QQmlPropertyData *
         bool isValueSource = false;
         bool isPropertyInterceptor = false;
 
-        QQmlType *qmlType = 0;
         const QV4::CompiledData::Object *targetObject = qmlUnit->objectAt(binding->value.objectIndex);
         if (auto *typeRef = resolvedTypes.value(targetObject->inheritedTypeNameIndex)) {
             QQmlPropertyCache *cache = typeRef->createPropertyCache(QQmlEnginePrivate::get(enginePrivate));
             const QMetaObject *mo = cache->firstCppMetaObject();
-            while (mo && !qmlType) {
+            QQmlType qmlType;
+            while (mo && !qmlType.isValid()) {
                 qmlType = QQmlMetaType::qmlType(mo);
                 mo = mo->superClass();
             }
-            Q_ASSERT(qmlType);
-        }
+            Q_ASSERT(qmlType.isValid());
 
-        if (qmlType) {
-            isValueSource = qmlType->propertyValueSourceCast() != -1;
-            isPropertyInterceptor = qmlType->propertyValueInterceptorCast() != -1;
+            isValueSource = qmlType.propertyValueSourceCast() != -1;
+            isPropertyInterceptor = qmlType.propertyValueInterceptorCast() != -1;
         }
 
         if (!isValueSource && !isPropertyInterceptor) {
diff --git a/src/qml/compiler/qqmltypecompiler.cpp b/src/qml/compiler/qqmltypecompiler.cpp
index c09fde86f1..9058a6c78f 100644
--- a/src/qml/compiler/qqmltypecompiler.cpp
+++ b/src/qml/compiler/qqmltypecompiler.cpp
@@ -75,7 +75,7 @@ QV4::CompiledData::CompilationUnit *QQmlTypeCompiler::compile()
 
     for (auto it = resolvedTypes.constBegin(), end = resolvedTypes.constEnd();
          it != end; ++it) {
-        QQmlCustomParser *customParser = (*it)->type ? (*it)->type->customParser() : 0;
+        QQmlCustomParser *customParser = (*it)->type.customParser();
         if (customParser)
             customParsers.insert(it.key(), customParser);
     }
@@ -171,7 +171,6 @@ QV4::CompiledData::CompilationUnit *QQmlTypeCompiler::compile()
     compilationUnit->propertyCaches = std::move(m_propertyCaches);
     Q_ASSERT(compilationUnit->propertyCaches.count() == static_cast<int>(compilationUnit->data->nObjects));
 
-
     if (errors.isEmpty())
         return compilationUnit;
     else
@@ -345,11 +344,11 @@ bool SignalHandlerConverter::convertSignalHandlerExpressionsToFunctionDeclaratio
         if (binding->type == QV4::CompiledData::Binding::Type_AttachedProperty) {
             const QmlIR::Object *attachedObj = qmlObjects.at(binding->value.objectIndex);
             auto *typeRef = resolvedTypes.value(binding->propertyNameIndex);
-            QQmlType *type = typeRef ? typeRef->type : 0;
-            if (!type) {
+            QQmlType type = typeRef ? typeRef->type : QQmlType();
+            if (!type.isValid()) {
                 if (imports->resolveType(propertyName, &type, 0, 0, 0)) {
-                    if (type->isComposite()) {
-                        QQmlTypeData *tdata = enginePrivate->typeLoader.getType(type->sourceUrl());
+                    if (type.isComposite()) {
+                        QQmlTypeData *tdata = enginePrivate->typeLoader.getType(type.sourceUrl());
                         Q_ASSERT(tdata);
                         Q_ASSERT(tdata->isComplete());
 
@@ -361,7 +360,7 @@ bool SignalHandlerConverter::convertSignalHandlerExpressionsToFunctionDeclaratio
                 }
             }
 
-            const QMetaObject *attachedType = type ? type->attachedPropertiesType(enginePrivate) : 0;
+            const QMetaObject *attachedType = type.attachedPropertiesType(enginePrivate);
             if (!attachedType)
                 COMPILE_EXCEPTION(binding, tr("Non-existent attached object"));
             QQmlPropertyCache *cache = compiler->enginePrivate()->cache(attachedType);
@@ -418,9 +417,9 @@ bool SignalHandlerConverter::convertSignalHandlerExpressionsToFunctionDeclaratio
                 const QString &originalPropertyName = stringAt(binding->propertyNameIndex);
 
                 auto *typeRef = resolvedTypes.value(obj->inheritedTypeNameIndex);
-                const QQmlType *type = typeRef ? typeRef->type : 0;
-                if (type) {
-                    COMPILE_EXCEPTION(binding, tr("\"%1.%2\" is not available in %3 %4.%5.").arg(typeName).arg(originalPropertyName).arg(type->module()).arg(type->majorVersion()).arg(type->minorVersion()));
+                const QQmlType type = typeRef->type;
+                if (type.isValid()) {
+                    COMPILE_EXCEPTION(binding, tr("\"%1.%2\" is not available in %3 %4.%5.").arg(typeName).arg(originalPropertyName).arg(type.module()).arg(type.majorVersion()).arg(type.minorVersion()));
                 } else {
                     COMPILE_EXCEPTION(binding, tr("\"%1.%2\" is not available due to component versioning.").arg(typeName).arg(originalPropertyName));
                 }
@@ -623,17 +622,17 @@ bool QQmlEnumTypeResolver::tryQualifiedEnumAssignment(const QmlIR::Object *obj,
         }
         return true;
     }
-    QQmlType *type = 0;
+    QQmlType type;
     imports->resolveType(typeName, &type, 0, 0, 0);
 
-    if (!type && !isQtObject)
+    if (!type.isValid() && !isQtObject)
         return true;
 
     int value = 0;
     bool ok = false;
 
     auto *tr = resolvedTypes->value(obj->inheritedTypeNameIndex);
-    if (type && tr && tr->type == type) {
+    if (type.isValid() && tr && tr->type == type) {
         // When these two match, we can short cut the search
         QMetaProperty mprop = propertyCache->firstCppMetaObject()->property(prop->coreIndex());
         QMetaEnum menum = mprop.enumerator();
@@ -648,11 +647,11 @@ bool QQmlEnumTypeResolver::tryQualifiedEnumAssignment(const QmlIR::Object *obj,
         }
     } else {
         // Otherwise we have to search the whole type
-        if (type) {
+        if (type.isValid()) {
             if (!scopedEnumName.isEmpty())
-                value = type->scopedEnumValue(compiler->enginePrivate(), scopedEnumName, enumValue, &ok);
+                value = type.scopedEnumValue(compiler->enginePrivate(), scopedEnumName, enumValue, &ok);
             else
-                value = type->enumValue(compiler->enginePrivate(), QHashedStringRef(enumValue), &ok);
+                value = type.enumValue(compiler->enginePrivate(), QHashedStringRef(enumValue), &ok);
         } else {
             QByteArray enumName = enumValue.toUtf8();
             const QMetaObject *metaObject = StaticQtMetaObject::get();
@@ -675,13 +674,13 @@ int QQmlEnumTypeResolver::evaluateEnum(const QString &scope, const QStringRef &e
     *ok = false;
 
     if (scope != QLatin1String("Qt")) {
-        QQmlType *type = 0;
+        QQmlType type;
         imports->resolveType(scope, &type, 0, 0, 0);
-        if (!type)
+        if (!type.isValid())
             return -1;
         if (!enumName.isEmpty())
-            return type->scopedEnumValue(compiler->enginePrivate(), enumName, enumValue, ok);
-        return type->enumValue(compiler->enginePrivate(), QHashedStringRef(enumValue.constData(), enumValue.length()), ok);
+            return type.scopedEnumValue(compiler->enginePrivate(), enumName, enumValue, ok);
+        return type.enumValue(compiler->enginePrivate(), QHashedStringRef(enumValue.constData(), enumValue.length()), ok);
     }
 
     const QMetaObject *mo = StaticQtMetaObject::get();
@@ -820,8 +819,8 @@ void QQmlComponentAndAliasResolver::findAndRegisterImplicitComponents(const QmlI
         const QmlIR::Object *targetObject = qmlObjects->at(binding->value.objectIndex);
         auto *tr = resolvedTypes->value(targetObject->inheritedTypeNameIndex);
         Q_ASSERT(tr);
-        if (QQmlType *targetType = tr->type) {
-            if (targetType->metaObject() == &QQmlComponent::staticMetaObject)
+        if (tr->type.isValid()) {
+            if (tr->type.metaObject() == &QQmlComponent::staticMetaObject)
                 continue;
         } else if (tr->compilationUnit) {
             if (tr->compilationUnit->rootPropertyCache()->firstCppMetaObject() == &QQmlComponent::staticMetaObject)
@@ -850,22 +849,22 @@ void QQmlComponentAndAliasResolver::findAndRegisterImplicitComponents(const QmlI
             continue;
 
         // emulate "import Qml 2.0 as QmlInternals" and then wrap the component in "QmlInternals.Component {}"
-        QQmlType *componentType = QQmlMetaType::qmlType(&QQmlComponent::staticMetaObject);
-        Q_ASSERT(componentType);
+        QQmlType componentType = QQmlMetaType::qmlType(&QQmlComponent::staticMetaObject);
+        Q_ASSERT(componentType.isValid());
         const QString qualifier = QStringLiteral("QmlInternals");
 
-        compiler->addImport(componentType->module(), qualifier, componentType->majorVersion(), componentType->minorVersion());
+        compiler->addImport(componentType.module(), qualifier, componentType.majorVersion(), componentType.minorVersion());
 
         QmlIR::Object *syntheticComponent = pool->New<QmlIR::Object>();
-        syntheticComponent->init(pool, compiler->registerString(qualifier + QLatin1Char('.') + componentType->elementName()), compiler->registerString(QString()));
+        syntheticComponent->init(pool, compiler->registerString(qualifier + QLatin1Char('.') + componentType.elementName()), compiler->registerString(QString()));
         syntheticComponent->location = binding->valueLocation;
         syntheticComponent->flags |= QV4::CompiledData::Object::IsComponent;
 
         if (!resolvedTypes->contains(syntheticComponent->inheritedTypeNameIndex)) {
             auto typeRef = new QV4::CompiledData::ResolvedTypeReference;
             typeRef->type = componentType;
-            typeRef->majorVersion = componentType->majorVersion();
-            typeRef->minorVersion = componentType->minorVersion();
+            typeRef->majorVersion = componentType.majorVersion();
+            typeRef->minorVersion = componentType.minorVersion();
             resolvedTypes->insert(syntheticComponent->inheritedTypeNameIndex, typeRef);
         }
 
@@ -906,7 +905,7 @@ bool QQmlComponentAndAliasResolver::resolve()
         if (obj->inheritedTypeNameIndex) {
             auto *tref = resolvedTypes->value(obj->inheritedTypeNameIndex);
             Q_ASSERT(tref);
-            if (tref->type && tref->type->metaObject() == &QQmlComponent::staticMetaObject)
+            if (tref->type.metaObject() == &QQmlComponent::staticMetaObject)
                 isExplicitComponent = true;
         }
         if (!isExplicitComponent) {
diff --git a/src/qml/compiler/qv4compileddata.cpp b/src/qml/compiler/qv4compileddata.cpp
index be7429df41..96b76d8cfd 100644
--- a/src/qml/compiler/qv4compileddata.cpp
+++ b/src/qml/compiler/qv4compileddata.cpp
@@ -57,6 +57,7 @@
 #include <QScopedValueRollback>
 #include <QStandardPaths>
 #include <QDir>
+#include <private/qv4identifiertable_p.h>
 #endif
 #include <private/qqmlirbuilder_p.h>
 #include <QCoreApplication>
@@ -127,7 +128,7 @@ QV4::Function *CompilationUnit::linkToEngine(ExecutionEngine *engine)
     // memset the strings to 0 in case a GC run happens while we're within the loop below
     memset(runtimeStrings, 0, data->stringTableSize * sizeof(QV4::Heap::String*));
     for (uint i = 0; i < data->stringTableSize; ++i)
-        runtimeStrings[i] = engine->newIdentifier(data->stringAt(i));
+        runtimeStrings[i] = engine->newString(data->stringAt(i));
 
     runtimeRegularExpressions = new QV4::Value[data->regexpTableSize];
     // memset the regexps to 0 in case a GC run happens while we're within the loop below
@@ -179,7 +180,7 @@ QV4::Function *CompilationUnit::linkToEngine(ExecutionEngine *engine)
             const CompiledData::JSClassMember *member = data->jsClassAt(i, &memberCount);
             QV4::InternalClass *klass = engine->internalClasses[QV4::ExecutionEngine::Class_Object];
             for (int j = 0; j < memberCount; ++j, ++member)
-                klass = klass->addMember(runtimeStrings[member->nameOffset]->identifier, member->isAccessor ? QV4::Attr_Accessor : QV4::Attr_Data);
+                klass = klass->addMember(engine->identifierTable->identifier(runtimeStrings[member->nameOffset]), member->isAccessor ? QV4::Attr_Accessor : QV4::Attr_Data);
 
             runtimeClasses[i] = klass;
         }
@@ -210,8 +211,9 @@ void CompilationUnit::unlink()
 
     if (isRegisteredWithEngine) {
         Q_ASSERT(data && quint32(propertyCaches.count()) > data->indexOfRootObject && propertyCaches.at(data->indexOfRootObject));
-        QQmlEnginePrivate *qmlEngine = QQmlEnginePrivate::get(propertyCaches.at(data->indexOfRootObject)->engine);
-        qmlEngine->unregisterInternalCompositeType(this);
+        if (engine)
+            QQmlEnginePrivate::get(engine)->unregisterInternalCompositeType(this);
+        QQmlMetaType::unregisterInternalCompositeType(this);
         isRegisteredWithEngine = false;
     }
 
@@ -284,9 +286,10 @@ IdentifierHash<int> CompilationUnit::namedObjectsPerComponent(int componentObjec
 void CompilationUnit::finalize(QQmlEnginePrivate *engine)
 {
     // Add to type registry of composites
-    if (propertyCaches.needsVMEMetaObject(data->indexOfRootObject))
+    if (propertyCaches.needsVMEMetaObject(data->indexOfRootObject)) {
+        QQmlMetaType::registerInternalCompositeType(this);
         engine->registerInternalCompositeType(this);
-    else {
+    } else {
         const QV4::CompiledData::Object *obj = objectAt(data->indexOfRootObject);
         auto *typeRef = resolvedTypes.value(obj->inheritedTypeNameIndex);
         Q_ASSERT(typeRef);
@@ -294,8 +297,8 @@ void CompilationUnit::finalize(QQmlEnginePrivate *engine)
             metaTypeId = typeRef->compilationUnit->metaTypeId;
             listMetaTypeId = typeRef->compilationUnit->listMetaTypeId;
         } else {
-            metaTypeId = typeRef->type->typeId();
-            listMetaTypeId = typeRef->type->qListTypeId();
+            metaTypeId = typeRef->type.typeId();
+            listMetaTypeId = typeRef->type.qListTypeId();
         }
     }
 
@@ -307,8 +310,8 @@ void CompilationUnit::finalize(QQmlEnginePrivate *engine)
         const QV4::CompiledData::Object *obj = data->objectAt(i);
         bindingCount += obj->nBindings;
         if (auto *typeRef = resolvedTypes.value(obj->inheritedTypeNameIndex)) {
-            if (QQmlType *qmlType = typeRef->type) {
-                if (qmlType->parserStatusCast() != -1)
+            if (typeRef->type.isValid()) {
+                if (typeRef->type.parserStatusCast() != -1)
                     ++parserStatusCount;
             }
             ++objectCount;
@@ -672,7 +675,7 @@ Returns the property cache, if one alread exists.  The cache is not referenced.
 */
 QQmlPropertyCache *ResolvedTypeReference::propertyCache() const
 {
-    if (type)
+    if (type.isValid())
         return typePropertyCache;
     else
         return compilationUnit->rootPropertyCache();
@@ -685,8 +688,8 @@ QQmlPropertyCache *ResolvedTypeReference::createPropertyCache(QQmlEngine *engine
 {
     if (typePropertyCache) {
         return typePropertyCache;
-    } else if (type) {
-        typePropertyCache = QQmlEnginePrivate::get(engine)->cache(type->metaObject());
+    } else if (type.isValid()) {
+        typePropertyCache = QQmlEnginePrivate::get(engine)->cache(type.metaObject());
         return typePropertyCache;
     } else {
         return compilationUnit->rootPropertyCache();
@@ -695,7 +698,7 @@ QQmlPropertyCache *ResolvedTypeReference::createPropertyCache(QQmlEngine *engine
 
 bool ResolvedTypeReference::addToHash(QCryptographicHash *hash, QQmlEngine *engine)
 {
-    if (type) {
+    if (type.isValid()) {
         bool ok = false;
         hash->addData(createPropertyCache(engine)->checksum(&ok));
         return ok;
@@ -719,8 +722,8 @@ void ResolvedTypeReference::doDynamicTypeCheck()
     const QMetaObject *mo = 0;
     if (typePropertyCache)
         mo = typePropertyCache->firstCppMetaObject();
-    else if (type)
-        mo = type->metaObject();
+    else if (type.isValid())
+        mo = type.metaObject();
     else if (compilationUnit)
         mo = compilationUnit->rootPropertyCache()->firstCppMetaObject();
     isFullyDynamicType = qtTypeInherits<QQmlPropertyMap>(mo);
diff --git a/src/qml/compiler/qv4compileddata_p.h b/src/qml/compiler/qv4compileddata_p.h
index b28f77e6e6..6ad53fca4f 100644
--- a/src/qml/compiler/qv4compileddata_p.h
+++ b/src/qml/compiler/qv4compileddata_p.h
@@ -967,13 +967,12 @@ protected:
 struct ResolvedTypeReference
 {
     ResolvedTypeReference()
-        : type(0)
-        , majorVersion(0)
+        : majorVersion(0)
         , minorVersion(0)
         , isFullyDynamicType(false)
     {}
 
-    QQmlType *type;
+    QQmlType type;
     QQmlRefPointer<QQmlPropertyCache> typePropertyCache;
     QQmlRefPointer<QV4::CompiledData::CompilationUnit> compilationUnit;
 
diff --git a/src/qml/compiler/qv4jsir_p.h b/src/qml/compiler/qv4jsir_p.h
index 190fb1bd5b..fb65eb4d8c 100644
--- a/src/qml/compiler/qv4jsir_p.h
+++ b/src/qml/compiler/qv4jsir_p.h
@@ -54,6 +54,9 @@
 #include <private/qqmljsmemorypool_p.h>
 #include <private/qqmljsastfwd_p.h>
 #include <private/qflagpointer_p.h>
+#ifndef V4_BOOTSTRAP
+#include <private/qqmlmetatype_p.h>
+#endif
 
 #include <QtCore/private/qnumeric_p.h>
 #include <QtCore/QVector>
@@ -77,6 +80,8 @@ class QQmlType;
 class QQmlPropertyData;
 class QQmlPropertyCache;
 class QQmlEnginePrivate;
+struct QQmlImportRef;
+class QQmlTypeNameCache;
 
 namespace QV4 {
 
@@ -248,14 +253,18 @@ struct MemberExpressionResolver
                                               Member *member);
 
     MemberExpressionResolver()
-        : resolveMember(0), data(0), extraData(0), owner(nullptr), flags(0) {}
+        : resolveMember(0), import(nullptr), propertyCache(nullptr), typenameCache(nullptr), owner(nullptr), flags(0) {}
 
     bool isValid() const { return !!resolveMember; }
     void clear() { *this = MemberExpressionResolver(); }
 
     ResolveFunction resolveMember;
-    void *data; // Could be pointer to meta object, importNameSpace, etc. - depends on resolveMember implementation
-    void *extraData; // Could be QQmlTypeNameCache
+#ifndef V4_BOOTSTRAP
+    QQmlType qmlType;
+#endif
+    const QQmlImportRef *import;
+    QQmlPropertyCache *propertyCache;
+    QQmlTypeNameCache *typenameCache;
     Function *owner;
     unsigned int flags;
 };