qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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>
This commit is contained in:
Simon Hausmann 2016-05-23 15:20:29 +02:00
parent 6f4c8ff345
commit a681465023
10 changed files with 60 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
src/qml/compiler/qqmltypecompiler.cpp
View File

@ -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;

28
src/qml/compiler/qqmltypecompiler_p.h
View File

@ -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

2
src/qml/qml/qqmlcompileddata.cpp
View File

@ -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)

9
src/qml/qml/qqmlcompiler_p.h
View File

@ -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 *);

12
src/qml/qml/qqmlobjectcreator.cpp
View File

@ -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;

3
src/qml/qml/qqmlobjectcreator_p.h
View File

@ -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;

5
src/qml/qml/qqmlvmemetaobject.cpp
View File

@ -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();

9
src/qml/qml/qqmlvmemetaobject_p.h
View File

@ -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;

16
src/quick/designer/qqmldesignermetaobject.cpp
View File

@ -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)

7
tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
View File

@ -248,8 +248,6 @@ private slots:
void earlyIdObjectAccess();
void dataAlignment();
void deleteSingletons();
void arrayBuffer_data();
@ -4131,11 +4129,6 @@ void tst_qqmllanguage::earlyIdObjectAccess()
QVERIFY(o->property("success").toBool());
}
void tst_qqmllanguage::dataAlignment()
{
QVERIFY(sizeof(QQmlVMEMetaData) % sizeof(int) == 0);
}
void tst_qqmllanguage::deleteSingletons()
{
QPointer<QObject> singleton;