QML: Split qqmlmetatype{_p.h|.cpp} into multiple files

Having all those classes in one big file promotes spaghetti code and
makes the code unreadable.

Change-Id: I3b6df93b9cfe1d97228771049b3054e78b868ea3
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

1 files changed, 1129 insertions, 0 deletions

diff --git a/src/qml/qml/qqmltype.cpp b/src/qml/qml/qqmltype.cpp
new file mode 100644
index 0000000000..1c69cedcd6
--- /dev/null
+++ b/src/qml/qml/qqmltype.cpp
@@ -0,0 +1,1129 @@
+/****************************************************************************
+**
+** Copyright (C) 2019 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqmltype_p_p.h"
+
+#include <QtQml/qjsvalue.h>
+#include <QtQml/qqmlengine.h>
+#include <QtQml/qqmlcontext.h>
+#include <QtQml/qqmlcomponent.h>
+
+#include <private/qqmlcustomparser_p.h>
+#include <private/qqmldata_p.h>
+#include <private/qqmlmetatypedata_p.h>
+#include <private/qqmlpropertycache_p.h>
+
+QT_BEGIN_NAMESPACE
+
+void QQmlType::SingletonInstanceInfo::init(QQmlEngine *e)
+{
+    if (scriptCallback && scriptApi(e).isUndefined()) {
+        QJSValue value = scriptCallback(e, e);
+        if (value.isQObject()) {
+            QObject *o = value.toQObject();
+            // even though the object is defined in C++, qmlContext(obj) and qmlEngine(obj)
+            // should behave identically to QML singleton types.
+            e->setContextForObject(o, new QQmlContext(e->rootContext(), e));
+        }
+        setScriptApi(e, value);
+    } else if (qobjectCallback && !qobjectApi(e)) {
+        QObject *o = qobjectCallback(e, e);
+        setQObjectApi(e, o);
+        if (!o) {
+            qFatal("qmlRegisterSingletonType(): \"%s\" is not available because the callback function returns a null pointer.", qPrintable(typeName));
+        }
+        // if this object can use a property cache, create it now
+        QQmlData::ensurePropertyCache(e, o);
+        // even though the object is defined in C++, qmlContext(obj) and qmlEngine(obj)
+        // should behave identically to QML singleton types.
+        e->setContextForObject(o, new QQmlContext(e->rootContext(), e));
+    } else if (!url.isEmpty() && !qobjectApi(e)) {
+        QQmlComponent component(e, url, QQmlComponent::PreferSynchronous);
+        QObject *o = component.beginCreate(e->rootContext());
+        setQObjectApi(e, o);
+        if (o)
+            component.completeCreate();
+    }
+}
+
+void QQmlType::SingletonInstanceInfo::destroy(QQmlEngine *e)
+{
+    // cleans up the engine-specific singleton instances if they exist.
+    scriptApis.remove(e);
+    QObject *o = qobjectApis.take(e);
+    if (o) {
+        QQmlData *ddata = QQmlData::get(o, false);
+        if (url.isEmpty() && ddata && ddata->indestructible && ddata->explicitIndestructibleSet)
+            return;
+        delete o;
+    }
+}
+
+void QQmlType::SingletonInstanceInfo::setQObjectApi(QQmlEngine *e, QObject *o)
+{
+    qobjectApis.insert(e, o);
+}
+
+QObject *QQmlType::SingletonInstanceInfo::qobjectApi(QQmlEngine *e) const
+{
+    return qobjectApis.value(e);
+}
+
+void QQmlType::SingletonInstanceInfo::setScriptApi(QQmlEngine *e, const QJSValue &v)
+{
+    scriptApis.insert(e, v);
+}
+
+QJSValue QQmlType::SingletonInstanceInfo::scriptApi(QQmlEngine *e) const
+{
+    return scriptApis.value(e);
+}
+
+QHash<const QMetaObject *, int> QQmlTypePrivate::attachedPropertyIds;
+
+QQmlTypePrivate::QQmlTypePrivate(QQmlType::RegistrationType type)
+    : refCount(1), regType(type), iid(nullptr), typeId(0), listId(0), revision(0),
+    containsRevisionedAttributes(false), baseMetaObject(nullptr),
+    index(-1), isSetup(false), isEnumSetup(false), haveSuperType(false)
+{
+    switch (type) {
+    case QQmlType::CppType:
+        extraData.cd = new QQmlCppTypeData;
+        extraData.cd->allocationSize = 0;
+        extraData.cd->newFunc = nullptr;
+        extraData.cd->parserStatusCast = -1;
+        extraData.cd->extFunc = nullptr;
+        extraData.cd->extMetaObject = nullptr;
+        extraData.cd->customParser = nullptr;
+        extraData.cd->attachedPropertiesFunc = nullptr;
+        extraData.cd->attachedPropertiesType = nullptr;
+        extraData.cd->propertyValueSourceCast = -1;
+        extraData.cd->propertyValueInterceptorCast = -1;
+        extraData.cd->registerEnumClassesUnscoped = true;
+        break;
+    case QQmlType::SingletonType:
+    case QQmlType::CompositeSingletonType:
+        extraData.sd = new QQmlSingletonTypeData;
+        extraData.sd->singletonInstanceInfo = nullptr;
+        break;
+    case QQmlType::InterfaceType:
+        extraData.cd = nullptr;
+        break;
+    case QQmlType::CompositeType:
+        extraData.fd = new QQmlCompositeTypeData;
+        break;
+    default: qFatal("QQmlTypePrivate Internal Error.");
+    }
+}
+
+QQmlTypePrivate::~QQmlTypePrivate()
+{
+    qDeleteAll(scopedEnums);
+    switch (regType) {
+    case QQmlType::CppType:
+        delete extraData.cd->customParser;
+        delete extraData.cd;
+        break;
+    case QQmlType::SingletonType:
+    case QQmlType::CompositeSingletonType:
+        delete extraData.sd->singletonInstanceInfo;
+        delete extraData.sd;
+        break;
+    case QQmlType::CompositeType:
+        delete extraData.fd;
+        break;
+    default: //Also InterfaceType, because it has no extra data
+        break;
+    }
+}
+
+QQmlType::QQmlType(QQmlMetaTypeData *data, const QQmlPrivate::RegisterInterface &interface)
+    : d(new QQmlTypePrivate(InterfaceType))
+{
+    d->iid = interface.iid;
+    d->typeId = interface.typeId;
+    d->listId = interface.listId;
+    d->isSetup = true;
+    d->version_maj = 0;
+    d->version_min = 0;
+    data->registerType(d);
+}
+
+QQmlType::QQmlType(QQmlMetaTypeData *data, const QString &elementName, const QQmlPrivate::RegisterSingletonType &type)
+    : d(new QQmlTypePrivate(SingletonType))
+{
+    data->registerType(d);
+
+    d->elementName = elementName;
+    d->module = QString::fromUtf8(type.uri);
+
+    d->version_maj = type.versionMajor;
+    d->version_min = type.versionMinor;
+
+    if (type.qobjectApi) {
+        if (type.version >= 1) // static metaobject added in version 1
+            d->baseMetaObject = type.instanceMetaObject;
+        if (type.version >= 2) // typeId added in version 2
+            d->typeId = type.typeId;
+        if (type.version >= 2) // revisions added in version 2
+            d->revision = type.revision;
+    }
+
+    d->extraData.sd->singletonInstanceInfo = new SingletonInstanceInfo;
+    d->extraData.sd->singletonInstanceInfo->scriptCallback = type.scriptApi;
+    d->extraData.sd->singletonInstanceInfo->qobjectCallback = type.qobjectApi;
+    d->extraData.sd->singletonInstanceInfo->typeName = QString::fromUtf8(type.typeName);
+    d->extraData.sd->singletonInstanceInfo->instanceMetaObject
+            = (type.qobjectApi && type.version >= 1) ? type.instanceMetaObject : nullptr;
+}
+
+QQmlType::QQmlType(QQmlMetaTypeData *data, const QString &elementName, const QQmlPrivate::RegisterCompositeSingletonType &type)
+    : d(new QQmlTypePrivate(CompositeSingletonType))
+{
+    data->registerType(d);
+
+    d->elementName = elementName;
+    d->module = QString::fromUtf8(type.uri);
+
+    d->version_maj = type.versionMajor;
+    d->version_min = type.versionMinor;
+
+    d->extraData.sd->singletonInstanceInfo = new SingletonInstanceInfo;
+    d->extraData.sd->singletonInstanceInfo->url = QQmlTypeLoader::normalize(type.url);
+    d->extraData.sd->singletonInstanceInfo->typeName = QString::fromUtf8(type.typeName);
+}
+
+QQmlType::QQmlType(QQmlMetaTypeData *data, const QString &elementName, const QQmlPrivate::RegisterType &type)
+    : d(new QQmlTypePrivate(CppType))
+{
+    data->registerType(d);
+
+    d->elementName = elementName;
+    d->module = QString::fromUtf8(type.uri);
+
+    d->version_maj = type.versionMajor;
+    d->version_min = type.versionMinor;
+    if (type.version >= 1) // revisions added in version 1
+        d->revision = type.revision;
+    d->typeId = type.typeId;
+    d->listId = type.listId;
+    d->extraData.cd->allocationSize = type.objectSize;
+    d->extraData.cd->newFunc = type.create;
+    d->extraData.cd->noCreationReason = type.noCreationReason;
+    d->baseMetaObject = type.metaObject;
+    d->extraData.cd->attachedPropertiesFunc = type.attachedPropertiesFunction;
+    d->extraData.cd->attachedPropertiesType = type.attachedPropertiesMetaObject;
+    if (d->extraData.cd->attachedPropertiesType) {
+        auto iter = QQmlTypePrivate::attachedPropertyIds.find(d->baseMetaObject);
+        if (iter == QQmlTypePrivate::attachedPropertyIds.end())
+            iter = QQmlTypePrivate::attachedPropertyIds.insert(d->baseMetaObject, d->index);
+        d->extraData.cd->attachedPropertiesId = *iter;
+    } else {
+        d->extraData.cd->attachedPropertiesId = -1;
+    }
+    d->extraData.cd->parserStatusCast = type.parserStatusCast;
+    d->extraData.cd->propertyValueSourceCast = type.valueSourceCast;
+    d->extraData.cd->propertyValueInterceptorCast = type.valueInterceptorCast;
+    d->extraData.cd->extFunc = type.extensionObjectCreate;
+    d->extraData.cd->customParser = type.customParser;
+    d->extraData.cd->registerEnumClassesUnscoped = true;
+
+    if (type.extensionMetaObject)
+        d->extraData.cd->extMetaObject = type.extensionMetaObject;
+
+    // Check if the user wants only scoped enum classes
+    if (d->baseMetaObject) {
+        auto indexOfClassInfo = d->baseMetaObject->indexOfClassInfo("RegisterEnumClassesUnscoped");
+        if (indexOfClassInfo != -1 && QString::fromUtf8(d->baseMetaObject->classInfo(indexOfClassInfo).value()) == QLatin1String("false"))
+            d->extraData.cd->registerEnumClassesUnscoped = false;
+    }
+}
+
+QQmlType::QQmlType(QQmlMetaTypeData *data, const QString &elementName, const QQmlPrivate::RegisterCompositeType &type)
+    : d(new QQmlTypePrivate(CompositeType))
+{
+    data->registerType(d);
+
+    d->elementName = elementName;
+
+    d->module = QString::fromUtf8(type.uri);
+    d->version_maj = type.versionMajor;
+    d->version_min = type.versionMinor;
+
+    d->extraData.fd->url = QQmlTypeLoader::normalize(type.url);
+}
+
+QQmlType::QQmlType()
+    : d(nullptr)
+{
+}
+
+QQmlType::QQmlType(const QQmlType &other)
+    : d(other.d)
+{
+    if (d)
+        d->refCount.ref();
+}
+
+QQmlType &QQmlType::operator =(const QQmlType &other)
+{
+    if (d != other.d) {
+        if (d && !d->refCount.deref())
+            delete d;
+        d = other.d;
+        if (d)
+            d->refCount.ref();
+    }
+    return *this;
+}
+
+QQmlType::QQmlType(QQmlTypePrivate *priv)
+    : d(priv)
+{
+    if (d)
+        d->refCount.ref();
+}
+
+QQmlType::~QQmlType()
+{
+    if (d && !d->refCount.deref()) {
+        // If attached properties were successfully registered, deregister them.
+        // (They may not have been registered if some other type used the same baseMetaObject)
+        if (d->regType == CppType && d->extraData.cd->attachedPropertiesType) {
+            auto it = QQmlTypePrivate::attachedPropertyIds.find(d->baseMetaObject);
+            if (it != QQmlTypePrivate::attachedPropertyIds.end() && *it == d->index)
+                QQmlTypePrivate::attachedPropertyIds.erase(it);
+        }
+        delete d;
+    }
+}
+
+QHashedString QQmlType::module() const
+{
+    if (!d)
+        return QHashedString();
+    return d->module;
+}
+
+int QQmlType::majorVersion() const
+{
+    if (!d)
+        return -1;
+    return d->version_maj;
+}
+
+int QQmlType::minorVersion() const
+{
+    if (!d)
+        return -1;
+    return d->version_min;
+}
+
+bool QQmlType::availableInVersion(int vmajor, int vminor) const
+{
+    Q_ASSERT(vmajor >= 0 && vminor >= 0);
+    if (!d)
+        return false;
+    return vmajor == d->version_maj && vminor >= d->version_min;
+}
+
+bool QQmlType::availableInVersion(const QHashedStringRef &module, int vmajor, int vminor) const
+{
+    Q_ASSERT(vmajor >= 0 && vminor >= 0);
+    if (!d)
+        return false;
+    return module == d->module && vmajor == d->version_maj && vminor >= d->version_min;
+}
+
+// returns the nearest _registered_ super class
+QQmlType QQmlType::superType() const
+{
+    if (!d)
+        return QQmlType();
+    if (!d->haveSuperType && d->baseMetaObject) {
+        const QMetaObject *mo = d->baseMetaObject->superClass();
+        while (mo && !d->superType.isValid()) {
+            d->superType = QQmlMetaType::qmlType(mo, d->module, d->version_maj, d->version_min);
+            mo = mo->superClass();
+        }
+        d->haveSuperType = true;
+    }
+
+    return d->superType;
+}
+
+QQmlType QQmlType::resolveCompositeBaseType(QQmlEnginePrivate *engine) const
+{
+    Q_ASSERT(isComposite());
+    if (!engine || !d)
+        return QQmlType();
+    QQmlRefPointer<QQmlTypeData> td(engine->typeLoader.getType(sourceUrl()));
+    if (td.isNull() || !td->isComplete())
+        return QQmlType();
+    QV4::CompiledData::CompilationUnit *compilationUnit = td->compilationUnit();
+    const QMetaObject *mo = compilationUnit->rootPropertyCache()->firstCppMetaObject();
+    return QQmlMetaType::qmlType(mo);
+}
+
+QQmlPropertyCache *QQmlType::compositePropertyCache(QQmlEnginePrivate *engine) const
+{
+    // similar logic to resolveCompositeBaseType
+    Q_ASSERT(isComposite());
+    if (!engine)
+        return nullptr;
+    QQmlRefPointer<QQmlTypeData> td(engine->typeLoader.getType(sourceUrl()));
+    if (td.isNull() || !td->isComplete())
+        return nullptr;
+    QV4::CompiledData::CompilationUnit *compilationUnit = td->compilationUnit();
+    return compilationUnit->rootPropertyCache().data();
+}
+
+static bool isPropertyRevisioned(const QMetaObject *mo, int index)
+{
+    int i = index;
+    i -= mo->propertyOffset();
+    if (i < 0 && mo->d.superdata)
+        return isPropertyRevisioned(mo->d.superdata, index);
+
+    const QMetaObjectPrivate *mop = reinterpret_cast<const QMetaObjectPrivate*>(mo->d.data);
+    if (i >= 0 && i < mop->propertyCount) {
+        int handle = mop->propertyData + 3*i;
+        int flags = mo->d.data[handle + 2];
+
+        return (flags & Revisioned);
+    }
+
+    return false;
+}
+
+void QQmlTypePrivate::init() const
+{
+    if (isSetup)
+        return;
+
+    QMutexLocker lock(QQmlMetaType::typeRegistrationLock());
+    if (isSetup)
+        return;
+
+    const QMetaObject *mo = baseMetaObject;
+    if (!mo) {
+        // version 0 singleton type without metaobject information
+        return;
+    }
+
+    if (regType == QQmlType::CppType) {
+        // Setup extended meta object
+        // XXX - very inefficient
+        if (extraData.cd->extFunc) {
+            QMetaObjectBuilder builder;
+            QQmlMetaType::clone(builder, extraData.cd->extMetaObject, extraData.cd->extMetaObject,
+                                extraData.cd->extMetaObject);
+            builder.setFlags(QMetaObjectBuilder::DynamicMetaObject);
+            QMetaObject *mmo = builder.toMetaObject();
+            mmo->d.superdata = mo;
+            QQmlProxyMetaObject::ProxyData data = { mmo, extraData.cd->extFunc, 0, 0 };
+            metaObjects << data;
+        }
+    }
+
+    metaObjects.append(QQmlMetaType::proxyData(
+            mo, baseMetaObject, metaObjects.isEmpty() ? nullptr
+                                                      : metaObjects.constLast().metaObject));
+
+    for (int ii = 0; ii < metaObjects.count(); ++ii) {
+        metaObjects[ii].propertyOffset =
+                metaObjects.at(ii).metaObject->propertyOffset();
+        metaObjects[ii].methodOffset =
+                metaObjects.at(ii).metaObject->methodOffset();
+    }
+
+    // Check for revisioned details
+    {
+        const QMetaObject *mo = nullptr;
+        if (metaObjects.isEmpty())
+            mo = baseMetaObject;
+        else
+            mo = metaObjects.constFirst().metaObject;
+
+        for (int ii = 0; !containsRevisionedAttributes && ii < mo->propertyCount(); ++ii) {
+            if (isPropertyRevisioned(mo, ii))
+                containsRevisionedAttributes = true;
+        }
+
+        for (int ii = 0; !containsRevisionedAttributes && ii < mo->methodCount(); ++ii) {
+            if (mo->method(ii).revision() != 0)
+                containsRevisionedAttributes = true;
+        }
+    }
+
+    isSetup = true;
+    lock.unlock();
+}
+
+void QQmlTypePrivate::initEnums(const QQmlPropertyCache *cache) const
+{
+    if (isEnumSetup) return;
+
+    init();
+
+    QMutexLocker lock(QQmlMetaType::typeRegistrationLock());
+    if (isEnumSetup) return;
+
+    if (cache)
+        insertEnumsFromPropertyCache(cache);
+    if (baseMetaObject) // could be singleton type without metaobject
+        insertEnums(baseMetaObject);
+
+    isEnumSetup = true;
+}
+
+void QQmlTypePrivate::insertEnums(const QMetaObject *metaObject) const
+{
+    // Add any enum values defined by 'related' classes
+    if (metaObject->d.relatedMetaObjects) {
+        const auto *related = metaObject->d.relatedMetaObjects;
+        if (related) {
+            while (*related)
+                insertEnums(*related++);
+        }
+    }
+
+    QSet<QString> localEnums;
+    const QMetaObject *localMetaObject = nullptr;
+
+    // Add any enum values defined by this class, overwriting any inherited values
+    for (int ii = 0; ii < metaObject->enumeratorCount(); ++ii) {
+        QMetaEnum e = metaObject->enumerator(ii);
+        const bool isScoped = e.isScoped();
+        QStringHash<int> *scoped = isScoped ? new QStringHash<int>() : nullptr;
+
+    // We allow enums in sub-classes to overwrite enums from base-classes, such as
+    // ListView.Center (from enum PositionMode) overwriting Item.Center (from enum TransformOrigin).
+    // This is acceptable because the _use_ of the enum from the QML side requires qualification
+    // anyway, i.e. ListView.Center vs. Item.Center.
+        // However if a class defines two enums with the same value, then that must produce a warning
+        // because it represents a valid conflict.
+        if (e.enclosingMetaObject() != localMetaObject) {
+            localEnums.clear();
+            localMetaObject = e.enclosingMetaObject();
+        }
+
+        for (int jj = 0; jj < e.keyCount(); ++jj) {
+            const QString key = QString::fromUtf8(e.key(jj));
+            const int value = e.value(jj);
+            if (!isScoped || (regType == QQmlType::CppType && extraData.cd->registerEnumClassesUnscoped)) {
+                if (localEnums.contains(key)) {
+                    auto existingEntry = enums.find(key);
+                    if (existingEntry != enums.end() && existingEntry.value() != value) {
+                        qWarning("Previously registered enum will be overwritten due to name clash: %s.%s", metaObject->className(), key.toUtf8().constData());
+                        createEnumConflictReport(metaObject, key);
+                    }
+                } else {
+                    localEnums.insert(key);
+                }
+                enums.insert(key, value);
+            }
+            if (isScoped)
+                scoped->insert(key, value);
+        }
+
+        if (isScoped) {
+            scopedEnums << scoped;
+            scopedEnumIndex.insert(QString::fromUtf8(e.name()), scopedEnums.count()-1);
+        }
+    }
+}
+
+void QQmlTypePrivate::createListOfPossibleConflictingItems(const QMetaObject *metaObject, QList<EnumInfo> &enumInfoList, QStringList path) const
+{
+    path.append(QString::fromUtf8(metaObject->className()));
+
+    if (metaObject->d.relatedMetaObjects) {
+        const auto *related = metaObject->d.relatedMetaObjects;
+        if (related) {
+            while (*related)
+                createListOfPossibleConflictingItems(*related++, enumInfoList, path);
+        }
+    }
+
+    for (int ii = 0; ii < metaObject->enumeratorCount(); ++ii) {
+        const auto e = metaObject->enumerator(ii);
+
+        for (int jj = 0; jj < e.keyCount(); ++jj) {
+            const QString key = QString::fromUtf8(e.key(jj));
+
+            EnumInfo enumInfo;
+            enumInfo.metaObjectName = QString::fromUtf8(metaObject->className());
+            enumInfo.enumName = QString::fromUtf8(e.name());
+            enumInfo.enumKey = key;
+            enumInfo.scoped = e.isScoped();
+            enumInfo.path = path;
+            enumInfo.metaEnumScope = QString::fromUtf8(e.scope());
+            enumInfoList.append(enumInfo);
+        }
+    }
+}
+
+void QQmlTypePrivate::createEnumConflictReport(const QMetaObject *metaObject, const QString &conflictingKey) const
+{
+    QList<EnumInfo> enumInfoList;
+
+    if (baseMetaObject) // prefer baseMetaObject if available
+        metaObject = baseMetaObject;
+
+    if (!metaObject) { // If there is no metaObject at all return early
+        qWarning() << "No meta object information available. Skipping conflict analysis.";
+        return;
+    }
+
+    createListOfPossibleConflictingItems(metaObject, enumInfoList, QStringList());
+
+    qWarning().noquote() << QLatin1String("Possible conflicting items:");
+    // find items with conflicting key
+    for (const auto i : enumInfoList) {
+        if (i.enumKey == conflictingKey)
+        qWarning().noquote().nospace() << "    " << i.metaObjectName << "." << i.enumName << "." << i.enumKey << " from scope "
+                                           << i.metaEnumScope << " injected by " << i.path.join(QLatin1String("->"));
+    }
+}
+
+void QQmlTypePrivate::insertEnumsFromPropertyCache(const QQmlPropertyCache *cache) const
+{
+    const QMetaObject *cppMetaObject = cache->firstCppMetaObject();
+
+    while (cache && cache->metaObject() != cppMetaObject) {
+
+        int count = cache->qmlEnumCount();
+        for (int ii = 0; ii < count; ++ii) {
+            QStringHash<int> *scoped = new QStringHash<int>();
+            QQmlEnumData *enumData = cache->qmlEnum(ii);
+
+            for (int jj = 0; jj < enumData->values.count(); ++jj) {
+                const QQmlEnumValue &value = enumData->values.at(jj);
+                enums.insert(value.namedValue, value.value);
+                scoped->insert(value.namedValue, value.value);
+            }
+            scopedEnums << scoped;
+            scopedEnumIndex.insert(enumData->name, scopedEnums.count()-1);
+        }
+        cache = cache->parent();
+    }
+    insertEnums(cppMetaObject);
+}
+
+
+QQmlPropertyCache *QQmlTypePrivate::propertyCacheForMinorVersion(int minorVersion) const
+{
+    for (int i = 0; i < propertyCaches.count(); ++i)
+        if (propertyCaches.at(i).minorVersion == minorVersion)
+            return propertyCaches.at(i).cache.data();
+    return nullptr;
+}
+
+void QQmlTypePrivate::setPropertyCacheForMinorVersion(int minorVersion, QQmlPropertyCache *cache)
+{
+    for (int i = 0; i < propertyCaches.count(); ++i) {
+        if (propertyCaches.at(i).minorVersion == minorVersion) {
+            propertyCaches[i].cache = cache;
+            return;
+        }
+    }
+    propertyCaches.append(PropertyCacheByMinorVersion(cache, minorVersion));
+}
+
+QByteArray QQmlType::typeName() const
+{
+    if (d) {
+        if (d->regType == SingletonType || d->regType == CompositeSingletonType)
+            return d->extraData.sd->singletonInstanceInfo->typeName.toUtf8();
+        else if (d->baseMetaObject)
+            return d->baseMetaObject->className();
+    }
+    return QByteArray();
+}
+
+QString QQmlType::elementName() const
+{
+    if (!d)
+        return QString();
+    return d->elementName;
+}
+
+QString QQmlType::qmlTypeName() const
+{
+    if (!d)
+        return QString();
+    if (d->name.isEmpty()) {
+        if (!d->module.isEmpty())
+            d->name = static_cast<QString>(d->module) + QLatin1Char('/') + d->elementName;
+        else
+            d->name = d->elementName;
+    }
+
+    return d->name;
+}
+
+QObject *QQmlType::create() const
+{
+    if (!d || !isCreatable())
+        return nullptr;
+
+    d->init();
+
+    QObject *rv = (QObject *)operator new(d->extraData.cd->allocationSize);
+    d->extraData.cd->newFunc(rv);
+
+    if (rv && !d->metaObjects.isEmpty())
+        (void)new QQmlProxyMetaObject(rv, &d->metaObjects);
+
+    return rv;
+}
+
+void QQmlType::create(QObject **out, void **memory, size_t additionalMemory) const
+{
+    if (!d || !isCreatable())
+        return;
+
+    d->init();
+
+    QObject *rv = (QObject *)operator new(d->extraData.cd->allocationSize + additionalMemory);
+    d->extraData.cd->newFunc(rv);
+
+    if (rv && !d->metaObjects.isEmpty())
+        (void)new QQmlProxyMetaObject(rv, &d->metaObjects);
+
+    *out = rv;
+    *memory = ((char *)rv) + d->extraData.cd->allocationSize;
+}
+
+QQmlType::SingletonInstanceInfo *QQmlType::singletonInstanceInfo() const
+{
+    if (!d)
+        return nullptr;
+    if (d->regType != SingletonType && d->regType != CompositeSingletonType)
+        return nullptr;
+    return d->extraData.sd->singletonInstanceInfo;
+}
+
+QQmlCustomParser *QQmlType::customParser() const
+{
+    if (!d)
+        return nullptr;
+    if (d->regType != CppType)
+        return nullptr;
+    return d->extraData.cd->customParser;
+}
+
+QQmlType::CreateFunc QQmlType::createFunction() const
+{
+    if (!d || d->regType != CppType)
+        return nullptr;
+    return d->extraData.cd->newFunc;
+}
+
+QString QQmlType::noCreationReason() const
+{
+    if (!d || d->regType != CppType)
+        return QString();
+    return d->extraData.cd->noCreationReason;
+}
+
+bool QQmlType::isCreatable() const
+{
+    return d && d->regType == CppType && d->extraData.cd->newFunc;
+}
+
+QQmlType::ExtensionFunc QQmlType::extensionFunction() const
+{
+    if (!d || d->regType != CppType)
+        return nullptr;
+    return d->extraData.cd->extFunc;
+}
+
+bool QQmlType::isExtendedType() const
+{
+    if (!d)
+        return false;
+    d->init();
+
+    return !d->metaObjects.isEmpty();
+}
+
+bool QQmlType::isSingleton() const
+{
+    return d && (d->regType == SingletonType || d->regType == CompositeSingletonType);
+}
+
+bool QQmlType::isInterface() const
+{
+    return d && d->regType == InterfaceType;
+}
+
+bool QQmlType::isComposite() const
+{
+    return d && (d->regType == CompositeType || d->regType == CompositeSingletonType);
+}
+
+bool QQmlType::isCompositeSingleton() const
+{
+    return d && d->regType == CompositeSingletonType;
+}
+
+int QQmlType::typeId() const
+{
+    return d ? d->typeId : -1;
+}
+
+int QQmlType::qListTypeId() const
+{
+    return d ? d->listId : -1;
+}
+
+const QMetaObject *QQmlType::metaObject() const
+{
+    if (!d)
+        return nullptr;
+    d->init();
+
+    if (d->metaObjects.isEmpty())
+        return d->baseMetaObject;
+    else
+        return d->metaObjects.constFirst().metaObject;
+
+}
+
+const QMetaObject *QQmlType::baseMetaObject() const
+{
+    return d ? d->baseMetaObject : nullptr;
+}
+
+bool QQmlType::containsRevisionedAttributes() const
+{
+    if (!d)
+        return false;
+    d->init();
+
+    return d->containsRevisionedAttributes;
+}
+
+int QQmlType::metaObjectRevision() const
+{
+    return d ? d->revision : -1;
+}
+
+QQmlAttachedPropertiesFunc QQmlType::attachedPropertiesFunction(QQmlEnginePrivate *engine) const
+{
+    if (!d)
+        return nullptr;
+    if (d->regType == CppType)
+        return d->extraData.cd->attachedPropertiesFunc;
+
+    QQmlType base;
+    if (d->regType == CompositeType)
+        base = resolveCompositeBaseType(engine);
+    return base.attachedPropertiesFunction(engine);
+}
+
+const QMetaObject *QQmlType::attachedPropertiesType(QQmlEnginePrivate *engine) const
+{
+    if (!d)
+        return nullptr;
+    if (d->regType == CppType)
+        return d->extraData.cd->attachedPropertiesType;
+
+    QQmlType base;
+    if (d->regType == CompositeType)
+        base = resolveCompositeBaseType(engine);
+    return base.attachedPropertiesType(engine);
+}
+
+/*
+This is the id passed to qmlAttachedPropertiesById().  This is different from the index
+for the case that a single class is registered under two or more names (eg. Item in
+Qt 4.7 and QtQuick 1.0).
+*/
+int QQmlType::attachedPropertiesId(QQmlEnginePrivate *engine) const
+{
+    if (!d)
+        return -1;
+    if (d->regType == CppType)
+        return d->extraData.cd->attachedPropertiesId;
+
+    QQmlType base;
+    if (d->regType == CompositeType)
+        base = resolveCompositeBaseType(engine);
+    return base.attachedPropertiesId(engine);
+}
+
+int QQmlType::parserStatusCast() const
+{
+    if (!d || d->regType != CppType)
+        return -1;
+    return d->extraData.cd->parserStatusCast;
+}
+
+int QQmlType::propertyValueSourceCast() const
+{
+    if (!d || d->regType != CppType)
+        return -1;
+    return d->extraData.cd->propertyValueSourceCast;
+}
+
+int QQmlType::propertyValueInterceptorCast() const
+{
+    if (!d || d->regType != CppType)
+        return -1;
+    return d->extraData.cd->propertyValueInterceptorCast;
+}
+
+const char *QQmlType::interfaceIId() const
+{
+    if (!d || d->regType != InterfaceType)
+        return nullptr;
+    return d->iid;
+}
+
+int QQmlType::index() const
+{
+    return d ? d->index : -1;
+}
+
+QUrl QQmlType::sourceUrl() const
+{
+    if (d) {
+        if (d->regType == CompositeType)
+            return d->extraData.fd->url;
+        else if (d->regType == CompositeSingletonType)
+            return d->extraData.sd->singletonInstanceInfo->url;
+    }
+    return QUrl();
+}
+
+int QQmlType::enumValue(QQmlEnginePrivate *engine, const QHashedStringRef &name, bool *ok) const
+{
+    Q_ASSERT(ok);
+    if (d) {
+        const QQmlPropertyCache *cache = isComposite() ? compositePropertyCache(engine) : nullptr;
+
+        *ok = true;
+
+        d->initEnums(cache);
+
+        int *rv = d->enums.value(name);
+        if (rv)
+            return *rv;
+    }
+
+    *ok = false;
+    return -1;
+}
+
+int QQmlType::enumValue(QQmlEnginePrivate *engine, const QHashedCStringRef &name, bool *ok) const
+{
+    Q_ASSERT(ok);
+    if (d) {
+        const QQmlPropertyCache *cache = isComposite() ? compositePropertyCache(engine) : nullptr;
+
+        *ok = true;
+
+        d->initEnums(cache);
+
+        int *rv = d->enums.value(name);
+        if (rv)
+            return *rv;
+    }
+
+    *ok = false;
+    return -1;
+}
+
+int QQmlType::enumValue(QQmlEnginePrivate *engine, const QV4::String *name, bool *ok) const
+{
+    Q_ASSERT(ok);
+    if (d) {
+        const QQmlPropertyCache *cache = isComposite() ? compositePropertyCache(engine) : nullptr;
+        *ok = true;
+
+        d->initEnums(cache);
+
+        int *rv = d->enums.value(name);
+        if (rv)
+            return *rv;
+    }
+
+    *ok = false;
+    return -1;
+}
+
+int QQmlType::scopedEnumIndex(QQmlEnginePrivate *engine, const QV4::String *name, bool *ok) const
+{
+    Q_ASSERT(ok);
+    if (d) {
+        const QQmlPropertyCache *cache = isComposite() ? compositePropertyCache(engine) : nullptr;
+        *ok = true;
+
+        d->initEnums(cache);
+
+        int *rv = d->scopedEnumIndex.value(name);
+        if (rv)
+            return *rv;
+    }
+
+    *ok = false;
+    return -1;
+}
+
+int QQmlType::scopedEnumIndex(QQmlEnginePrivate *engine, const QString &name, bool *ok) const
+{
+    Q_ASSERT(ok);
+    if (d) {
+        const QQmlPropertyCache *cache = isComposite() ? compositePropertyCache(engine) : nullptr;
+        *ok = true;
+
+        d->initEnums(cache);
+
+        int *rv = d->scopedEnumIndex.value(name);
+        if (rv)
+            return *rv;
+    }
+
+    *ok = false;
+    return -1;
+}
+
+int QQmlType::scopedEnumValue(QQmlEnginePrivate *engine, int index, const QV4::String *name, bool *ok) const
+{
+    Q_UNUSED(engine)
+    Q_ASSERT(ok);
+    *ok = true;
+
+    if (d) {
+        Q_ASSERT(index > -1 && index < d->scopedEnums.count());
+        int *rv = d->scopedEnums.at(index)->value(name);
+        if (rv)
+            return *rv;
+    }
+
+    *ok = false;
+    return -1;
+}
+
+int QQmlType::scopedEnumValue(QQmlEnginePrivate *engine, int index, const QString &name, bool *ok) const
+{
+    Q_UNUSED(engine)
+    Q_ASSERT(ok);
+    *ok = true;
+
+    if (d) {
+        Q_ASSERT(index > -1 && index < d->scopedEnums.count());
+        int *rv = d->scopedEnums.at(index)->value(name);
+        if (rv)
+            return *rv;
+    }
+
+    *ok = false;
+    return -1;
+}
+
+int QQmlType::scopedEnumValue(QQmlEnginePrivate *engine, const QByteArray &scopedEnumName, const QByteArray &name, bool *ok) const
+{
+    Q_ASSERT(ok);
+    if (d) {
+        const QQmlPropertyCache *cache = isComposite() ? compositePropertyCache(engine) : nullptr;
+        *ok = true;
+
+        d->initEnums(cache);
+
+        int *rv = d->scopedEnumIndex.value(QHashedCStringRef(scopedEnumName.constData(), scopedEnumName.length()));
+        if (rv) {
+            int index = *rv;
+            Q_ASSERT(index > -1 && index < d->scopedEnums.count());
+            rv = d->scopedEnums.at(index)->value(QHashedCStringRef(name.constData(), name.length()));
+            if (rv)
+                return *rv;
+        }
+    }
+
+    *ok = false;
+    return -1;
+}
+
+int QQmlType::scopedEnumValue(QQmlEnginePrivate *engine, const QStringRef &scopedEnumName, const QStringRef &name, bool *ok) const
+{
+    Q_ASSERT(ok);
+    if (d) {
+        const QQmlPropertyCache *cache = isComposite() ? compositePropertyCache(engine) : nullptr;
+        *ok = true;
+
+        d->initEnums(cache);
+
+        int *rv = d->scopedEnumIndex.value(QHashedStringRef(scopedEnumName));
+        if (rv) {
+            int index = *rv;
+            Q_ASSERT(index > -1 && index < d->scopedEnums.count());
+            rv = d->scopedEnums.at(index)->value(QHashedStringRef(name));
+            if (rv)
+                return *rv;
+        }
+    }
+
+    *ok = false;
+    return -1;
+}
+
+void QQmlType::refHandle(QQmlTypePrivate *priv)
+{
+    if (priv)
+        priv->refCount.ref();
+}
+
+void QQmlType::derefHandle(QQmlTypePrivate *priv)
+{
+    if (priv && !priv->refCount.deref())
+        delete priv;
+}
+
+int QQmlType::refCount(QQmlTypePrivate *priv)
+{
+    if (priv)
+        return priv->refCount;
+    return -1;
+}
+
+QT_END_NAMESPACE