QML: Split propertyCache into multiple files

I want to be able to read the code.

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

28 files changed, 1623 insertions, 933 deletions

diff --git a/src/qml/compiler/qqmlirbuilder_p.h b/src/qml/compiler/qqmlirbuilder_p.h
index 5dd4d1800f..618c1340e6 100644
--- a/src/qml/compiler/qqmlirbuilder_p.h
+++ b/src/qml/compiler/qqmlirbuilder_p.h
@@ -60,10 +60,6 @@
 #include <QTextStream>
 #include <QCoreApplication>
 
-#ifndef V4_BOOTSTRAP
-#include <private/qqmlpropertycache_p.h>
-#endif
-
 QT_BEGIN_NAMESPACE
 
 class QQmlPropertyCache;
diff --git a/src/qml/compiler/qqmlpropertycachecreator_p.h b/src/qml/compiler/qqmlpropertycachecreator_p.h
index 02517ea6bb..c0c736035c 100644
--- a/src/qml/compiler/qqmlpropertycachecreator_p.h
+++ b/src/qml/compiler/qqmlpropertycachecreator_p.h
@@ -52,6 +52,7 @@
 
 #include <private/qqmlvaluetype_p.h>
 #include <private/qqmlengine_p.h>
+#include <private/qqmlmetaobject_p.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/qml/compiler/qv4compileddata.cpp b/src/qml/compiler/qv4compileddata.cpp
index c90bbf03e6..0db35fbd9e 100644
--- a/src/qml/compiler/qv4compileddata.cpp
+++ b/src/qml/compiler/qv4compileddata.cpp
@@ -46,7 +46,6 @@
 #include <private/qv4lookup_p.h>
 #include <private/qv4regexpobject_p.h>
 #include <private/qv4regexp_p.h>
-#include <private/qqmlpropertycache_p.h>
 #include <private/qqmltypeloader_p.h>
 #include <private/qqmlengine_p.h>
 #include <private/qv4vme_moth_p.h>
diff --git a/src/qml/compiler/qv4compileddata_p.h b/src/qml/compiler/qv4compileddata_p.h
index 7197b4cde8..5516a0637e 100644
--- a/src/qml/compiler/qv4compileddata_p.h
+++ b/src/qml/compiler/qv4compileddata_p.h
@@ -66,7 +66,7 @@
 #include <private/qqmljsastfwd_p.h>
 #ifndef V4_BOOTSTRAP
 #include <private/qqmltypenamecache_p.h>
-#include <private/qqmlpropertycache_p.h>
+#include <private/qqmlpropertycachevector_p.h>
 #include "private/qintrusivelist_p.h"
 #endif
 
@@ -76,7 +76,6 @@ QT_BEGIN_NAMESPACE
 #define QV4_DATA_STRUCTURE_VERSION 0x1b
 
 class QIODevice;
-class QQmlPropertyCache;
 class QQmlPropertyData;
 class QQmlTypeNameCache;
 class QQmlScriptData;
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 9344a231ff..d73927bab7 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -39,7 +39,7 @@
 
 #include "qv4qobjectwrapper_p.h"
 
-#include <private/qqmlpropertycache_p.h>
+#include <private/qqmlstaticmetaobject_p.h>
 #include <private/qqmlengine_p.h>
 #include <private/qqmlvmemetaobject_p.h>
 #include <private/qqmlbinding_p.h>
diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h
index 6465ee0fa6..3617c59c9a 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper_p.h
+++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h
@@ -57,7 +57,6 @@
 #include <QtCore/qhash.h>
 #include <private/qhashedstring_p.h>
 #include <private/qqmldata_p.h>
-#include <private/qqmlpropertycache_p.h>
 #include <private/qintrusivelist_p.h>
 
 #include <private/qv4value_p.h>
diff --git a/src/qml/qml/qml.pri b/src/qml/qml/qml.pri
index ca13ce9211..eaa21c97ae 100644
--- a/src/qml/qml/qml.pri
+++ b/src/qml/qml/qml.pri
@@ -21,7 +21,10 @@ SOURCES += \
     $$PWD/qqmlvaluetype.cpp \
     $$PWD/qqmlcleanup.cpp \
     $$PWD/qqmlpropertycache.cpp \
+    $$PWD/qqmlmetaobject.cpp \
     $$PWD/qqmlnotifier.cpp \
+    $$PWD/qqmlobjectorgadget.cpp \
+    $$PWD/qqmlstaticmetaobject.cpp \
     $$PWD/qqmltypenotavailable.cpp \
     $$PWD/qqmltypenamecache.cpp \
     $$PWD/qqmlscriptstring.cpp \
@@ -81,9 +84,18 @@ HEADERS += \
     $$PWD/qqmldata_p.h \
     $$PWD/qqmlvaluetype_p.h \
     $$PWD/qqmlcleanup_p.h \
+    $$PWD/qqmlenumdata_p.h \
+    $$PWD/qqmlenumvalue_p.h \
     $$PWD/qqmlpropertycache_p.h \
+    $$PWD/qqmlpropertycachemethodarguments_p.h \
+    $$PWD/qqmlpropertycachevector_p.h \
+    $$PWD/qqmlpropertydata_p.h \
     $$PWD/qqmlpropertyindex_p.h \
+    $$PWD/qqmlpropertyrawdata_p.h \
+    $$PWD/qqmlmetaobject_p.h \
     $$PWD/qqmlnotifier_p.h \
+    $$PWD/qqmlobjectorgadget_p.h \
+    $$PWD/qqmlstaticmetaobject_p.h \
     $$PWD/qqmltypenotavailable_p.h \
     $$PWD/qqmltypenamecache_p.h \
     $$PWD/qqmlscriptstring.h \
diff --git a/src/qml/qml/qqmlengine_p.h b/src/qml/qml/qqmlengine_p.h
index 70e188dc1c..f334f51298 100644
--- a/src/qml/qml/qqmlengine_p.h
+++ b/src/qml/qml/qqmlengine_p.h
@@ -62,7 +62,6 @@
 #include "qqmlcontext_p.h"
 #include "qqmlexpression.h"
 #include "qqmlproperty_p.h"
-#include "qqmlpropertycache_p.h"
 #include "qqmlmetatype_p.h"
 #include <private/qintrusivelist_p.h>
 #include <private/qrecyclepool_p.h>
@@ -101,6 +100,7 @@ class QDir;
 class QQmlIncubator;
 class QQmlProfiler;
 class QQmlPropertyCapture;
+class QQmlMetaObject;
 
 // This needs to be declared here so that the pool for it can live in QQmlEnginePrivate.
 // The inline method definitions are in qqmljavascriptexpression_p.h
diff --git a/src/qml/qml/qqmlenumdata_p.h b/src/qml/qml/qqmlenumdata_p.h
new file mode 100644
index 0000000000..df99c2c1bc
--- /dev/null
+++ b/src/qml/qml/qqmlenumdata_p.h
@@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLENUMDATA_P_H
+#define QQMLENUMDATA_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qqmlenumvalue_p.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QQmlEnumData
+{
+    QString name;
+    QVector<QQmlEnumValue> values;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLENUMDATA_P_H
diff --git a/src/qml/qml/qqmlenumvalue_p.h b/src/qml/qml/qqmlenumvalue_p.h
new file mode 100644
index 0000000000..ea0fc244cb
--- /dev/null
+++ b/src/qml/qml/qqmlenumvalue_p.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLENUMVALUE_P_H
+#define QQMLENUMVALUE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qstring.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QQmlEnumValue
+{
+    QQmlEnumValue() {}
+    QQmlEnumValue(const QString &n, int v) : namedValue(n), value(v) {}
+    QString namedValue;
+    int value = -1;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLENUMVALUE_P_H
diff --git a/src/qml/qml/qqmlglobal_p.h b/src/qml/qml/qqmlglobal_p.h
index 818537560c..e2d53ab555 100644
--- a/src/qml/qml/qqmlglobal_p.h
+++ b/src/qml/qml/qqmlglobal_p.h
@@ -53,7 +53,7 @@
 
 #include <private/qtqmlglobal_p.h>
 #include <QtCore/QObject>
-#include <private/qqmlpropertycache_p.h>
+#include <private/qqmlmetaobject_p.h>
 #include <private/qmetaobject_p.h>
 #include <private/qv8engine_p.h>
 
diff --git a/src/qml/qml/qqmllist_p.h b/src/qml/qml/qqmllist_p.h
index 04bab8d929..e182ced51d 100644
--- a/src/qml/qml/qqmllist_p.h
+++ b/src/qml/qml/qqmllist_p.h
@@ -52,7 +52,7 @@
 //
 
 #include "qqmllist.h"
-#include "qqmlpropertycache_p.h"
+#include "qqmlmetaobject_p.h"
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/qml/qml/qqmlmetaobject.cpp b/src/qml/qml/qqmlmetaobject.cpp
new file mode 100644
index 0000000000..a967f46b12
--- /dev/null
+++ b/src/qml/qml/qqmlmetaobject.cpp
@@ -0,0 +1,327 @@
+/****************************************************************************
+**
+** 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 "qqmlmetaobject_p.h"
+
+#include <private/qqmlengine_p.h>
+#include <private/qqmlpropertycachemethodarguments_p.h>
+
+QT_BEGIN_NAMESPACE
+
+struct StaticQtMetaObject : public QObject
+{
+    static const QMetaObject *get()
+    { return &staticQtMetaObject; }
+};
+
+static bool isNamedEnumeratorInScope(const QMetaObject *resolvedMetaObject, const QByteArray &scope,
+                                     const QByteArray &name)
+{
+    for (int i = resolvedMetaObject->enumeratorCount() - 1; i >= 0; --i) {
+        QMetaEnum m = resolvedMetaObject->enumerator(i);
+        if ((m.name() == name) && (scope.isEmpty() || (m.scope() == scope)))
+            return true;
+    }
+    return false;
+}
+
+static bool isNamedEnumerator(const QMetaObject *metaObj, const QByteArray &scopedName)
+{
+    QByteArray scope;
+    QByteArray name;
+    int scopeIdx = scopedName.lastIndexOf("::");
+    if (scopeIdx != -1) {
+        scope = scopedName.left(scopeIdx);
+        name = scopedName.mid(scopeIdx + 2);
+    } else {
+        name = scopedName;
+    }
+
+    if (scope == "Qt")
+        return isNamedEnumeratorInScope(StaticQtMetaObject::get(), scope, name);
+
+    if (isNamedEnumeratorInScope(metaObj, scope, name))
+        return true;
+
+    if (metaObj->d.relatedMetaObjects && !scope.isEmpty()) {
+        for (auto related = metaObj->d.relatedMetaObjects; *related; ++related) {
+            if (isNamedEnumeratorInScope(*related, scope, name))
+                return true;
+        }
+    }
+
+    return false;
+}
+
+// Returns true if \a from is assignable to a property of type \a to
+bool QQmlMetaObject::canConvert(const QQmlMetaObject &from, const QQmlMetaObject &to)
+{
+    Q_ASSERT(!from.isNull() && !to.isNull());
+
+    struct I { static bool equal(const QMetaObject *lhs, const QMetaObject *rhs) {
+            return lhs == rhs || (lhs && rhs && lhs->d.stringdata == rhs->d.stringdata);
+        } };
+
+    const QMetaObject *tom = to._m.isT1()?to._m.asT1()->metaObject():to._m.asT2();
+    if (tom == &QObject::staticMetaObject) return true;
+
+    if (from._m.isT1() && to._m.isT1()) { // QQmlPropertyCache -> QQmlPropertyCache
+        QQmlPropertyCache *fromp = from._m.asT1();
+        QQmlPropertyCache *top = to._m.asT1();
+
+        while (fromp) {
+            if (fromp == top) return true;
+            fromp = fromp->parent();
+        }
+    } else if (from._m.isT1() && to._m.isT2()) { // QQmlPropertyCache -> QMetaObject
+        QQmlPropertyCache *fromp = from._m.asT1();
+
+        while (fromp) {
+            const QMetaObject *fromm = fromp->metaObject();
+            if (fromm && I::equal(fromm, tom)) return true;
+            fromp = fromp->parent();
+        }
+    } else if (from._m.isT2() && to._m.isT1()) { // QMetaObject -> QQmlPropertyCache
+        const QMetaObject *fromm = from._m.asT2();
+
+        if (!tom) return false;
+
+        while (fromm) {
+            if (I::equal(fromm, tom)) return true;
+            fromm = fromm->superClass();
+        }
+    } else { // QMetaObject -> QMetaObject
+        const QMetaObject *fromm = from._m.asT2();
+
+        while (fromm) {
+            if (I::equal(fromm, tom)) return true;
+            fromm = fromm->superClass();
+        }
+    }
+
+    return false;
+}
+
+void QQmlMetaObject::resolveGadgetMethodOrPropertyIndex(QMetaObject::Call type, const QMetaObject **metaObject, int *index)
+{
+    int offset;
+
+    switch (type) {
+    case QMetaObject::ReadProperty:
+    case QMetaObject::WriteProperty:
+    case QMetaObject::ResetProperty:
+    case QMetaObject::QueryPropertyDesignable:
+    case QMetaObject::QueryPropertyEditable:
+    case QMetaObject::QueryPropertyScriptable:
+    case QMetaObject::QueryPropertyStored:
+    case QMetaObject::QueryPropertyUser:
+        offset = (*metaObject)->propertyOffset();
+        while (*index < offset) {
+            *metaObject = (*metaObject)->superClass();
+            offset = (*metaObject)->propertyOffset();
+        }
+        break;
+    case QMetaObject::InvokeMetaMethod:
+        offset = (*metaObject)->methodOffset();
+        while (*index < offset) {
+            *metaObject = (*metaObject)->superClass();
+            offset = (*metaObject)->methodOffset();
+        }
+        break;
+    default:
+        offset = 0;
+        Q_UNIMPLEMENTED();
+        offset = INT_MAX;
+    }
+
+    *index -= offset;
+}
+
+QQmlPropertyCache *QQmlMetaObject::propertyCache(QQmlEnginePrivate *e) const
+{
+    if (_m.isNull()) return nullptr;
+    if (_m.isT1()) return _m.asT1();
+    else return e->cache(_m.asT2());
+}
+
+int QQmlMetaObject::methodReturnType(const QQmlPropertyData &data, QByteArray *unknownTypeError) const
+{
+    Q_ASSERT(!_m.isNull() && data.coreIndex() >= 0);
+
+    int type = data.propType();
+
+    const char *propTypeName = nullptr;
+
+    if (type == QMetaType::UnknownType) {
+        // Find the return type name from the method info
+        QMetaMethod m;
+
+        if (_m.isT1()) {
+            QQmlPropertyCache *c = _m.asT1();
+            Q_ASSERT(data.coreIndex() < c->methodIndexCacheStart + c->methodIndexCache.count());
+
+            while (data.coreIndex() < c->methodIndexCacheStart)
+                c = c->_parent;
+
+            const QMetaObject *metaObject = c->createMetaObject();
+            Q_ASSERT(metaObject);
+            m = metaObject->method(data.coreIndex());
+        } else {
+            m = _m.asT2()->method(data.coreIndex());
+        }
+
+        type = m.returnType();
+        propTypeName = m.typeName();
+    }
+
+    if (QMetaType::sizeOf(type) <= int(sizeof(int))) {
+        if (QMetaType::typeFlags(type) & QMetaType::IsEnumeration)
+            return QMetaType::Int;
+
+        if (isNamedEnumerator(metaObject(), propTypeName))
+            return QMetaType::Int;
+
+        if (type == QMetaType::UnknownType) {
+            if (unknownTypeError)
+                *unknownTypeError = propTypeName;
+        }
+    } // else we know that it's a known type, as sizeOf(UnknownType) == 0
+
+    return type;
+}
+
+int *QQmlMetaObject::methodParameterTypes(int index, ArgTypeStorage *argStorage,
+                                          QByteArray *unknownTypeError) const
+{
+    Q_ASSERT(!_m.isNull() && index >= 0);
+
+    if (_m.isT1()) {
+        typedef QQmlPropertyCacheMethodArguments A;
+
+        QQmlPropertyCache *c = _m.asT1();
+        Q_ASSERT(index < c->methodIndexCacheStart + c->methodIndexCache.count());
+
+        while (index < c->methodIndexCacheStart)
+            c = c->_parent;
+
+        QQmlPropertyData *rv = const_cast<QQmlPropertyData *>(&c->methodIndexCache.at(index - c->methodIndexCacheStart));
+
+        if (rv->arguments() && static_cast<A *>(rv->arguments())->argumentsValid)
+            return static_cast<A *>(rv->arguments())->arguments;
+
+        const QMetaObject *metaObject = c->createMetaObject();
+        Q_ASSERT(metaObject);
+        QMetaMethod m = metaObject->method(index);
+
+        int argc = m.parameterCount();
+        if (!rv->arguments()) {
+            A *args = c->createArgumentsObject(argc, m.parameterNames());
+            rv->setArguments(args);
+        }
+        A *args = static_cast<A *>(rv->arguments());
+
+        QList<QByteArray> argTypeNames; // Only loaded if needed
+
+        for (int ii = 0; ii < argc; ++ii) {
+            int type = m.parameterType(ii);
+
+            if (QMetaType::sizeOf(type) > int(sizeof(int))) {
+                // Cannot be passed as int
+                // We know that it's a known type, as sizeOf(UnknownType) == 0
+            } else if (QMetaType::typeFlags(type) & QMetaType::IsEnumeration) {
+                type = QMetaType::Int;
+            } else {
+                if (argTypeNames.isEmpty())
+                    argTypeNames = m.parameterTypes();
+                if (isNamedEnumerator(metaObject, argTypeNames.at(ii))) {
+                    type = QMetaType::Int;
+                } else if (type == QMetaType::UnknownType){
+                    if (unknownTypeError)
+                        *unknownTypeError = argTypeNames.at(ii);
+                    return nullptr;
+                }
+
+            }
+            args->arguments[ii + 1] = type;
+        }
+        args->argumentsValid = true;
+        return static_cast<A *>(rv->arguments())->arguments;
+
+    } else {
+        QMetaMethod m = _m.asT2()->method(index);
+        return methodParameterTypes(m, argStorage, unknownTypeError);
+
+    }
+}
+
+int *QQmlMetaObject::methodParameterTypes(const QMetaMethod &m, ArgTypeStorage *argStorage,
+                                          QByteArray *unknownTypeError) const
+{
+    Q_ASSERT(argStorage);
+
+    int argc = m.parameterCount();
+    argStorage->resize(argc + 1);
+    argStorage->operator[](0) = argc;
+    QList<QByteArray> argTypeNames; // Only loaded if needed
+
+    for (int ii = 0; ii < argc; ++ii) {
+        int type = m.parameterType(ii);
+        if (QMetaType::sizeOf(type) > int(sizeof(int))) {
+            // Cannot be passed as int
+            // We know that it's a known type, as sizeOf(UnknownType) == 0
+        } else if (QMetaType::typeFlags(type) & QMetaType::IsEnumeration) {
+            type = QMetaType::Int;
+        } else {
+            if (argTypeNames.isEmpty())
+                argTypeNames = m.parameterTypes();
+            if (isNamedEnumerator(_m.asT2(), argTypeNames.at(ii))) {
+                type = QMetaType::Int;
+            } else if (type == QMetaType::UnknownType) {
+                if (unknownTypeError)
+                    *unknownTypeError = argTypeNames.at(ii);
+                return nullptr;
+            }
+        }
+        argStorage->operator[](ii + 1) = type;
+    }
+
+    return argStorage->data();
+}
+
+QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlmetaobject_p.h b/src/qml/qml/qqmlmetaobject_p.h
new file mode 100644
index 0000000000..65d6361b90
--- /dev/null
+++ b/src/qml/qml/qqmlmetaobject_p.h
@@ -0,0 +1,187 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLMETAOBJECT_P_H
+#define QQMLMETAOBJECT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQml/qtqmlglobal.h>
+
+#include <private/qflagpointer_p.h>
+#include <private/qqmlpropertycache_p.h>
+
+#include <QtCore/qvarlengtharray.h>
+#include <QtCore/qmetaobject.h>
+
+QT_BEGIN_NAMESPACE
+
+// QQmlMetaObject serves as a wrapper around either QMetaObject or QQmlPropertyCache.
+// This is necessary as we delay creation of QMetaObject for synthesized QObjects, but
+// we don't want to needlessly generate QQmlPropertyCaches every time we encounter a
+// QObject type used in assignment or when we don't have a QQmlEngine etc.
+//
+// This class does NOT reference the propertycache.
+class QQmlEnginePrivate;
+class QQmlPropertyData;
+class Q_QML_EXPORT QQmlMetaObject
+{
+public:
+    typedef QVarLengthArray<int, 9> ArgTypeStorage;
+
+    inline QQmlMetaObject();
+    inline QQmlMetaObject(QObject *);
+    inline QQmlMetaObject(const QMetaObject *);
+    inline QQmlMetaObject(QQmlPropertyCache *);
+    inline QQmlMetaObject(const QQmlMetaObject &);
+
+    inline QQmlMetaObject &operator=(const QQmlMetaObject &);
+
+    inline bool isNull() const;
+
+    inline const char *className() const;
+    inline int propertyCount() const;
+
+    inline bool hasMetaObject() const;
+    inline const QMetaObject *metaObject() const;
+
+    QQmlPropertyCache *propertyCache(QQmlEnginePrivate *) const;
+
+    int methodReturnType(const QQmlPropertyData &data, QByteArray *unknownTypeError) const;
+    int *methodParameterTypes(int index, ArgTypeStorage *argStorage,
+                              QByteArray *unknownTypeError) const;
+
+    static bool canConvert(const QQmlMetaObject &from, const QQmlMetaObject &to);
+
+    // static_metacall (on Gadgets) doesn't call the base implementation and therefore
+    // we need a helper to find the correct meta object and property/method index.
+    static void resolveGadgetMethodOrPropertyIndex(QMetaObject::Call type, const QMetaObject **metaObject, int *index);
+
+protected:
+    QBiPointer<QQmlPropertyCache, const QMetaObject> _m;
+    int *methodParameterTypes(const QMetaMethod &method, ArgTypeStorage *argStorage,
+                              QByteArray *unknownTypeError) const;
+
+};
+
+QQmlMetaObject::QQmlMetaObject()
+{
+}
+
+QQmlMetaObject::QQmlMetaObject(QObject *o)
+{
+    if (o) {
+        QQmlData *ddata = QQmlData::get(o, false);
+        if (ddata && ddata->propertyCache) _m = ddata->propertyCache;
+        else _m = o->metaObject();
+    }
+}
+
+QQmlMetaObject::QQmlMetaObject(const QMetaObject *m)
+    : _m(m)
+{
+}
+
+QQmlMetaObject::QQmlMetaObject(QQmlPropertyCache *m)
+    : _m(m)
+{
+}
+
+QQmlMetaObject::QQmlMetaObject(const QQmlMetaObject &o)
+    : _m(o._m)
+{
+}
+
+QQmlMetaObject &QQmlMetaObject::operator=(const QQmlMetaObject &o)
+{
+    _m = o._m;
+    return *this;
+}
+
+bool QQmlMetaObject::isNull() const
+{
+    return _m.isNull();
+}
+
+const char *QQmlMetaObject::className() const
+{
+    if (_m.isNull()) {
+        return nullptr;
+    } else if (_m.isT1()) {
+        return _m.asT1()->className();
+    } else {
+        return _m.asT2()->className();
+    }
+}
+
+int QQmlMetaObject::propertyCount() const
+{
+    if (_m.isNull()) {
+        return 0;
+    } else if (_m.isT1()) {
+        return _m.asT1()->propertyCount();
+    } else {
+        return _m.asT2()->propertyCount();
+    }
+}
+
+bool QQmlMetaObject::hasMetaObject() const
+{
+    return _m.isT2() || (!_m.isNull() && _m.asT1()->metaObject());
+}
+
+const QMetaObject *QQmlMetaObject::metaObject() const
+{
+    if (_m.isNull()) return nullptr;
+    if (_m.isT1()) return _m.asT1()->createMetaObject();
+    else return _m.asT2();
+}
+
+QT_END_NAMESPACE
+
+#endif // QQMLMETAOBJECT_P_H
diff --git a/src/qml/qml/qqmlmetatype_p.h b/src/qml/qml/qqmlmetatype_p.h
index 2a45ddb4bb..b04b7371a1 100644
--- a/src/qml/qml/qqmlmetatype_p.h
+++ b/src/qml/qml/qqmlmetatype_p.h
@@ -163,7 +163,6 @@ public:
 
 struct QQmlMetaTypeData;
 class QHashedCStringRef;
-class QQmlPropertyCache;
 class Q_QML_PRIVATE_EXPORT QQmlType
 {
 public:
diff --git a/src/qml/qml/qqmlobjectorgadget.cpp b/src/qml/qml/qqmlobjectorgadget.cpp
new file mode 100644
index 0000000000..1d4916d7d1
--- /dev/null
+++ b/src/qml/qml/qqmlobjectorgadget.cpp
@@ -0,0 +1,60 @@
+/****************************************************************************
+**
+** 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 "qqmlobjectorgadget_p.h"
+
+QT_BEGIN_NAMESPACE
+
+void QQmlObjectOrGadget::metacall(QMetaObject::Call type, int index, void **argv) const
+{
+    if (ptr.isNull()) {
+        const QMetaObject *metaObject = _m.asT2();
+        metaObject->d.static_metacall(nullptr, type, index, argv);
+    }
+    else if (ptr.isT1()) {
+        QMetaObject::metacall(ptr.asT1(), type, index, argv);
+    }
+    else {
+        const QMetaObject *metaObject = _m.asT1()->metaObject();
+        QQmlMetaObject::resolveGadgetMethodOrPropertyIndex(type, &metaObject, &index);
+        metaObject->d.static_metacall(reinterpret_cast<QObject*>(ptr.asT2()), type, index, argv);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlobjectorgadget_p.h b/src/qml/qml/qqmlobjectorgadget_p.h
new file mode 100644
index 0000000000..c5f5f58a3a
--- /dev/null
+++ b/src/qml/qml/qqmlobjectorgadget_p.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLOBJECTORGADGET_P_H
+#define QQMLOBJECTORGADGET_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qqmlmetaobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQmlObjectOrGadget: public QQmlMetaObject
+{
+public:
+    QQmlObjectOrGadget(QObject *obj)
+        : QQmlMetaObject(obj),
+        ptr(obj)
+    {}
+    QQmlObjectOrGadget(QQmlPropertyCache *propertyCache, void *gadget)
+        : QQmlMetaObject(propertyCache)
+        , ptr(gadget)
+    {}
+
+    void metacall(QMetaObject::Call type, int index, void **argv) const;
+
+private:
+    QBiPointer<QObject, void> ptr;
+
+protected:
+    QQmlObjectOrGadget(const QMetaObject* metaObject)
+        : QQmlMetaObject(metaObject)
+    {}
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLOBJECTORGADGET_P_H
diff --git a/src/qml/qml/qqmlproperty_p.h b/src/qml/qml/qqmlproperty_p.h
index 544eab4c7f..bafcba5971 100644
--- a/src/qml/qml/qqmlproperty_p.h
+++ b/src/qml/qml/qqmlproperty_p.h
@@ -56,7 +56,8 @@
 
 #include <private/qobject_p.h>
 #include <private/qtqmlglobal_p.h>
-#include <private/qqmlpropertycache_p.h>
+#include <private/qqmlrefcount_p.h>
+#include <private/qqmlcontext_p.h>
 #include <private/qqmlboundsignalexpressionpointer_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -64,6 +65,7 @@ QT_BEGIN_NAMESPACE
 class QQmlContext;
 class QQmlEnginePrivate;
 class QQmlJavaScriptExpression;
+class QQmlMetaObject;
 
 class Q_QML_PRIVATE_EXPORT QQmlPropertyPrivate : public QQmlRefCount
 {
diff --git a/src/qml/qml/qqmlpropertycache.cpp b/src/qml/qml/qqmlpropertycache.cpp
index d619730e28..8934827e5e 100644
--- a/src/qml/qml/qqmlpropertycache.cpp
+++ b/src/qml/qml/qqmlpropertycache.cpp
@@ -46,6 +46,7 @@
 
 #include <private/qmetaobject_p.h>
 #include <private/qmetaobjectbuilder_p.h>
+#include <private/qqmlpropertycachemethodarguments_p.h>
 
 #include <private/qv4value_p.h>
 
@@ -65,21 +66,6 @@ QT_BEGIN_NAMESPACE
 
 #define Q_INT16_MAX 32767
 
-class QQmlPropertyCacheMethodArguments
-{
-public:
-    QQmlPropertyCacheMethodArguments *next;
-
-    //for signal handler rewrites
-    QString *signalParameterStringForJS;
-    int parameterError:1;
-    int argumentsValid:1;
-
-    QList<QByteArray> *names;
-
-    int arguments[1];
-};
-
 // Flags that do *NOT* depend on the property's QMetaProperty::userType() and thus are quick
 // to load
 static QQmlPropertyData::Flags fastFlagsForProperty(const QMetaProperty &p)
@@ -883,51 +869,6 @@ void QQmlPropertyData::markAsOverrideOf(QQmlPropertyData *predecessor)
     predecessor->_flags.isOverridden = true;
 }
 
-struct StaticQtMetaObject : public QObject
-{
-    static const QMetaObject *get()
-        { return &staticQtMetaObject; }
-};
-
-static bool isNamedEnumeratorInScope(const QMetaObject *resolvedMetaObject, const QByteArray &scope,
-                                     const QByteArray &name)
-{
-    for (int i = resolvedMetaObject->enumeratorCount() - 1; i >= 0; --i) {
-        QMetaEnum m = resolvedMetaObject->enumerator(i);
-        if ((m.name() == name) && (scope.isEmpty() || (m.scope() == scope)))
-            return true;
-    }
-    return false;
-}
-
-static bool isNamedEnumerator(const QMetaObject *metaObj, const QByteArray &scopedName)
-{
-    QByteArray scope;
-    QByteArray name;
-    int scopeIdx = scopedName.lastIndexOf("::");
-    if (scopeIdx != -1) {
-        scope = scopedName.left(scopeIdx);
-        name = scopedName.mid(scopeIdx + 2);
-    } else {
-        name = scopedName;
-    }
-
-    if (scope == "Qt")
-        return isNamedEnumeratorInScope(StaticQtMetaObject::get(), scope, name);
-
-    if (isNamedEnumeratorInScope(metaObj, scope, name))
-        return true;
-
-    if (metaObj->d.relatedMetaObjects && !scope.isEmpty()) {
-        for (auto related = metaObj->d.relatedMetaObjects; *related; ++related) {
-            if (isNamedEnumeratorInScope(*related, scope, name))
-                return true;
-        }
-    }
-
-    return false;
-}
-
 QQmlPropertyCacheMethodArguments *QQmlPropertyCache::createArgumentsObject(int argc, const QList<QByteArray> &names)
 {
     typedef QQmlPropertyCacheMethodArguments A;
@@ -1508,262 +1449,4 @@ QList<QByteArray> QQmlPropertyCache::signalParameterNames(int index) const
     return QList<QByteArray>();
 }
 
-// Returns true if \a from is assignable to a property of type \a to
-bool QQmlMetaObject::canConvert(const QQmlMetaObject &from, const QQmlMetaObject &to)
-{
-    Q_ASSERT(!from.isNull() && !to.isNull());
-
-    struct I { static bool equal(const QMetaObject *lhs, const QMetaObject *rhs) {
-        return lhs == rhs || (lhs && rhs && lhs->d.stringdata == rhs->d.stringdata);
-    } };
-
-    const QMetaObject *tom = to._m.isT1()?to._m.asT1()->metaObject():to._m.asT2();
-    if (tom == &QObject::staticMetaObject) return true;
-
-    if (from._m.isT1() && to._m.isT1()) { // QQmlPropertyCache -> QQmlPropertyCache
-        QQmlPropertyCache *fromp = from._m.asT1();
-        QQmlPropertyCache *top = to._m.asT1();
-
-        while (fromp) {
-            if (fromp == top) return true;
-            fromp = fromp->parent();
-        }
-    } else if (from._m.isT1() && to._m.isT2()) { // QQmlPropertyCache -> QMetaObject
-        QQmlPropertyCache *fromp = from._m.asT1();
-
-        while (fromp) {
-            const QMetaObject *fromm = fromp->metaObject();
-            if (fromm && I::equal(fromm, tom)) return true;
-            fromp = fromp->parent();
-        }
-    } else if (from._m.isT2() && to._m.isT1()) { // QMetaObject -> QQmlPropertyCache
-        const QMetaObject *fromm = from._m.asT2();
-
-        if (!tom) return false;
-
-        while (fromm) {
-            if (I::equal(fromm, tom)) return true;
-            fromm = fromm->superClass();
-        }
-    } else { // QMetaObject -> QMetaObject
-        const QMetaObject *fromm = from._m.asT2();
-
-        while (fromm) {
-            if (I::equal(fromm, tom)) return true;
-            fromm = fromm->superClass();
-        }
-    }
-
-    return false;
-}
-
-void QQmlMetaObject::resolveGadgetMethodOrPropertyIndex(QMetaObject::Call type, const QMetaObject **metaObject, int *index)
-{
-    int offset;
-
-    switch (type) {
-    case QMetaObject::ReadProperty:
-    case QMetaObject::WriteProperty:
-    case QMetaObject::ResetProperty:
-    case QMetaObject::QueryPropertyDesignable:
-    case QMetaObject::QueryPropertyEditable:
-    case QMetaObject::QueryPropertyScriptable:
-    case QMetaObject::QueryPropertyStored:
-    case QMetaObject::QueryPropertyUser:
-        offset = (*metaObject)->propertyOffset();
-        while (*index < offset) {
-            *metaObject = (*metaObject)->superClass();
-            offset = (*metaObject)->propertyOffset();
-        }
-        break;
-    case QMetaObject::InvokeMetaMethod:
-        offset = (*metaObject)->methodOffset();
-        while (*index < offset) {
-            *metaObject = (*metaObject)->superClass();
-            offset = (*metaObject)->methodOffset();
-        }
-        break;
-    default:
-        offset = 0;
-        Q_UNIMPLEMENTED();
-        offset = INT_MAX;
-    }
-
-    *index -= offset;
-}
-
-QQmlPropertyCache *QQmlMetaObject::propertyCache(QQmlEnginePrivate *e) const
-{
-    if (_m.isNull()) return nullptr;
-    if (_m.isT1()) return _m.asT1();
-    else return e->cache(_m.asT2());
-}
-
-int QQmlMetaObject::methodReturnType(const QQmlPropertyData &data, QByteArray *unknownTypeError) const
-{
-    Q_ASSERT(!_m.isNull() && data.coreIndex() >= 0);
-
-    int type = data.propType();
-
-    const char *propTypeName = nullptr;
-
-    if (type == QMetaType::UnknownType) {
-        // Find the return type name from the method info
-        QMetaMethod m;
-
-        if (_m.isT1()) {
-            QQmlPropertyCache *c = _m.asT1();
-            Q_ASSERT(data.coreIndex() < c->methodIndexCacheStart + c->methodIndexCache.count());
-
-            while (data.coreIndex() < c->methodIndexCacheStart)
-                c = c->_parent;
-
-            const QMetaObject *metaObject = c->createMetaObject();
-            Q_ASSERT(metaObject);
-            m = metaObject->method(data.coreIndex());
-        } else {
-            m = _m.asT2()->method(data.coreIndex());
-        }
-
-        type = m.returnType();
-        propTypeName = m.typeName();
-    }
-
-    if (QMetaType::sizeOf(type) <= int(sizeof(int))) {
-        if (QMetaType::typeFlags(type) & QMetaType::IsEnumeration)
-            return QMetaType::Int;
-
-        if (isNamedEnumerator(metaObject(), propTypeName))
-            return QMetaType::Int;
-
-        if (type == QMetaType::UnknownType) {
-            if (unknownTypeError)
-                *unknownTypeError = propTypeName;
-        }
-    } // else we know that it's a known type, as sizeOf(UnknownType) == 0
-
-    return type;
-}
-
-int *QQmlMetaObject::methodParameterTypes(int index, ArgTypeStorage *argStorage,
-                                          QByteArray *unknownTypeError) const
-{
-    Q_ASSERT(!_m.isNull() && index >= 0);
-
-    if (_m.isT1()) {
-        typedef QQmlPropertyCacheMethodArguments A;
-
-        QQmlPropertyCache *c = _m.asT1();
-        Q_ASSERT(index < c->methodIndexCacheStart + c->methodIndexCache.count());
-
-        while (index < c->methodIndexCacheStart)
-            c = c->_parent;
-
-        QQmlPropertyData *rv = const_cast<QQmlPropertyData *>(&c->methodIndexCache.at(index - c->methodIndexCacheStart));
-
-        if (rv->arguments() && static_cast<A *>(rv->arguments())->argumentsValid)
-            return static_cast<A *>(rv->arguments())->arguments;
-
-        const QMetaObject *metaObject = c->createMetaObject();
-        Q_ASSERT(metaObject);
-        QMetaMethod m = metaObject->method(index);
-
-        int argc = m.parameterCount();
-        if (!rv->arguments()) {
-            A *args = c->createArgumentsObject(argc, m.parameterNames());
-            rv->setArguments(args);
-        }
-        A *args = static_cast<A *>(rv->arguments());
-
-        QList<QByteArray> argTypeNames; // Only loaded if needed
-
-        for (int ii = 0; ii < argc; ++ii) {
-            int type = m.parameterType(ii);
-
-            if (QMetaType::sizeOf(type) > int(sizeof(int))) {
-                // Cannot be passed as int
-                // We know that it's a known type, as sizeOf(UnknownType) == 0
-            } else if (QMetaType::typeFlags(type) & QMetaType::IsEnumeration) {
-                type = QMetaType::Int;
-            } else {
-                if (argTypeNames.isEmpty())
-                    argTypeNames = m.parameterTypes();
-                if (isNamedEnumerator(metaObject, argTypeNames.at(ii))) {
-                    type = QMetaType::Int;
-                } else if (type == QMetaType::UnknownType){
-                    if (unknownTypeError)
-                        *unknownTypeError = argTypeNames.at(ii);
-                    return nullptr;
-                }
-
-            }
-            args->arguments[ii + 1] = type;
-        }
-        args->argumentsValid = true;
-        return static_cast<A *>(rv->arguments())->arguments;
-
-    } else {
-        QMetaMethod m = _m.asT2()->method(index);
-        return methodParameterTypes(m, argStorage, unknownTypeError);
-
-    }
-}
-
-int *QQmlMetaObject::methodParameterTypes(const QMetaMethod &m, ArgTypeStorage *argStorage,
-                                          QByteArray *unknownTypeError) const
-{
-    Q_ASSERT(argStorage);
-
-    int argc = m.parameterCount();
-    argStorage->resize(argc + 1);
-    argStorage->operator[](0) = argc;
-    QList<QByteArray> argTypeNames; // Only loaded if needed
-
-    for (int ii = 0; ii < argc; ++ii) {
-        int type = m.parameterType(ii);
-        if (QMetaType::sizeOf(type) > int(sizeof(int))) {
-            // Cannot be passed as int
-            // We know that it's a known type, as sizeOf(UnknownType) == 0
-        } else if (QMetaType::typeFlags(type) & QMetaType::IsEnumeration) {
-            type = QMetaType::Int;
-        } else {
-            if (argTypeNames.isEmpty())
-                argTypeNames = m.parameterTypes();
-            if (isNamedEnumerator(_m.asT2(), argTypeNames.at(ii))) {
-                type = QMetaType::Int;
-            } else if (type == QMetaType::UnknownType) {
-                if (unknownTypeError)
-                    *unknownTypeError = argTypeNames.at(ii);
-                return nullptr;
-            }
-        }
-        argStorage->operator[](ii + 1) = type;
-    }
-
-    return argStorage->data();
-}
-
-void QQmlObjectOrGadget::metacall(QMetaObject::Call type, int index, void **argv) const
-{
-    if (ptr.isNull()) {
-        const QMetaObject *metaObject = _m.asT2();
-        metaObject->d.static_metacall(nullptr, type, index, argv);
-    }
-    else if (ptr.isT1()) {
-        QMetaObject::metacall(ptr.asT1(), type, index, argv);
-    }
-    else {
-        const QMetaObject *metaObject = _m.asT1()->metaObject();
-        QQmlMetaObject::resolveGadgetMethodOrPropertyIndex(type, &metaObject, &index);
-        metaObject->d.static_metacall(reinterpret_cast<QObject*>(ptr.asT2()), type, index, argv);
-    }
-}
-
-int *QQmlStaticMetaObject::constructorParameterTypes(int index, ArgTypeStorage *dummy,
-                                                     QByteArray *unknownTypeError) const
-{
-    QMetaMethod m = _m.asT2()->constructor(index);
-    return methodParameterTypes(m, dummy, unknownTypeError);
-}
-
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlpropertycache_p.h b/src/qml/qml/qqmlpropertycache_p.h
index 0785910cec..c072e9a8db 100644
--- a/src/qml/qml/qqmlpropertycache_p.h
+++ b/src/qml/qml/qqmlpropertycache_p.h
@@ -62,334 +62,20 @@
 #include <QtCore/qvector.h>
 
 #include <private/qv4value_p.h>
+#include <private/qqmlpropertydata_p.h>
+#include <private/qqmlenumdata_p.h>
+#include <private/qqmlenumvalue_p.h>
 
 #include <limits>
 
 QT_BEGIN_NAMESPACE
 
 class QCryptographicHash;
-class QMetaProperty;
-class QQmlEngine;
 class QJSEngine;
-class QQmlPropertyData;
 class QMetaObjectBuilder;
-class QQmlPropertyCacheMethodArguments;
 class QQmlVMEMetaObject;
-template <typename T> class QQmlPropertyCacheCreator;
-template <typename T> class QQmlPropertyCacheAliasCreator;
-
-// We have this somewhat awful split between RawData and Data so that RawData can be
-// used in unions.  In normal code, you should always use Data which initializes RawData
-// to an invalid state on construction.
-// ### We should be able to remove this split nowadays
-class QQmlPropertyRawData
-{
-public:
-    typedef QObjectPrivate::StaticMetaCallFunction StaticMetaCallFunction;
-
-    struct Flags {
-        enum Types {
-            OtherType            = 0,
-            FunctionType         = 1, // Is an invokable
-            QObjectDerivedType   = 2, // Property type is a QObject* derived type
-            EnumType             = 3, // Property type is an enum
-            QListType            = 4, // Property type is a QML list
-            QmlBindingType       = 5, // Property type is a QQmlBinding*
-            QJSValueType         = 6, // Property type is a QScriptValue
-            V4HandleType         = 7, // Property type is a QQmlV4Handle
-            VarPropertyType      = 8, // Property type is a "var" property of VMEMO
-            QVariantType         = 9  // Property is a QVariant
-        };
-
-        // The _otherBits (which "pad" the Flags struct to align it nicely) are used
-        // to store the relative property index. It will only get used when said index fits. See
-        // trySetStaticMetaCallFunction for details.
-        // (Note: this padding is done here, because certain compilers have surprising behavior
-        // when an enum is declared in-between two bit fields.)
-        enum { BitsLeftInFlags = 10 };
-        unsigned _otherBits       : BitsLeftInFlags; // align to 32 bits
-
-        // Can apply to all properties, except IsFunction
-        unsigned isConstant       : 1; // Has CONST flag
-        unsigned isWritable       : 1; // Has WRITE function
-        unsigned isResettable     : 1; // Has RESET function
-        unsigned isAlias          : 1; // Is a QML alias to another property
-        unsigned isFinal          : 1; // Has FINAL flag
-        unsigned isOverridden     : 1; // Is overridden by a extension property
-        unsigned isDirect         : 1; // Exists on a C++ QMetaObject
-
-        unsigned type             : 4; // stores an entry of Types
-
-        // Apply only to IsFunctions
-        unsigned isVMEFunction    : 1; // Function was added by QML
-        unsigned hasArguments     : 1; // Function takes arguments
-        unsigned isSignal         : 1; // Function is a signal
-        unsigned isVMESignal      : 1; // Signal was added by QML
-        unsigned isV4Function     : 1; // Function takes QQmlV4Function* args
-        unsigned isSignalHandler  : 1; // Function is a signal handler
-        unsigned isOverload       : 1; // Function is an overload of another function
-        unsigned isCloned         : 1; // The function was marked as cloned
-        unsigned isConstructor    : 1; // The function was marked is a constructor
-
-        // Internal QQmlPropertyCache flags
-        unsigned notFullyResolved : 1; // True if the type data is to be lazily resolved
-        unsigned overrideIndexIsProperty: 1;
-
-        inline Flags();
-        inline bool operator==(const Flags &other) const;
-        inline void copyPropertyTypeFlags(Flags from);
-    };
-
-    Flags flags() const { return _flags; }
-    void setFlags(Flags f)
-    {
-        unsigned otherBits = _flags._otherBits;
-        _flags = f;
-        _flags._otherBits = otherBits;
-    }
-
-    bool isValid() const { return coreIndex() != -1; }
-
-    bool isConstant() const { return _flags.isConstant; }
-    bool isWritable() const { return _flags.isWritable; }
-    void setWritable(bool onoff) { _flags.isWritable = onoff; }
-    bool isResettable() const { return _flags.isResettable; }
-    bool isAlias() const { return _flags.isAlias; }
-    bool isFinal() const { return _flags.isFinal; }
-    bool isOverridden() const { return _flags.isOverridden; }
-    bool isDirect() const { return _flags.isDirect; }
-    bool hasStaticMetaCallFunction() const { return staticMetaCallFunction() != nullptr; }
-    bool isFunction() const { return _flags.type == Flags::FunctionType; }
-    bool isQObject() const { return _flags.type == Flags::QObjectDerivedType; }
-    bool isEnum() const { return _flags.type == Flags::EnumType; }
-    bool isQList() const { return _flags.type == Flags::QListType; }
-    bool isQmlBinding() const { return _flags.type == Flags::QmlBindingType; }
-    bool isQJSValue() const { return _flags.type == Flags::QJSValueType; }
-    bool isV4Handle() const { return _flags.type == Flags::V4HandleType; }
-    bool isVarProperty() const { return _flags.type == Flags::VarPropertyType; }
-    bool isQVariant() const { return _flags.type == Flags::QVariantType; }
-    bool isVMEFunction() const { return _flags.isVMEFunction; }
-    bool hasArguments() const { return _flags.hasArguments; }
-    bool isSignal() const { return _flags.isSignal; }
-    bool isVMESignal() const { return _flags.isVMESignal; }
-    bool isV4Function() const { return _flags.isV4Function; }
-    bool isSignalHandler() const { return _flags.isSignalHandler; }
-    bool isOverload() const { return _flags.isOverload; }
-    void setOverload(bool onoff) { _flags.isOverload = onoff; }
-    bool isCloned() const { return _flags.isCloned; }
-    bool isConstructor() const { return _flags.isConstructor; }
-
-    bool hasOverride() const { return overrideIndex() >= 0; }
-    bool hasRevision() const { return revision() != 0; }
-
-    bool isFullyResolved() const { return !_flags.notFullyResolved; }
-
-    int propType() const { Q_ASSERT(isFullyResolved()); return _propType; }
-    void setPropType(int pt)
-    {
-        Q_ASSERT(pt >= 0);
-        Q_ASSERT(pt <= std::numeric_limits<qint16>::max());
-        _propType = quint16(pt);
-    }
-
-    int notifyIndex() const { return _notifyIndex; }
-    void setNotifyIndex(int idx)
-    {
-        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
-        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
-        _notifyIndex = qint16(idx);
-    }
-
-    bool overrideIndexIsProperty() const { return _flags.overrideIndexIsProperty; }
-    void setOverrideIndexIsProperty(bool onoff) { _flags.overrideIndexIsProperty = onoff; }
-
-    int overrideIndex() const { return _overrideIndex; }
-    void setOverrideIndex(int idx)
-    {
-        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
-        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
-        _overrideIndex = qint16(idx);
-    }
-
-    int coreIndex() const { return _coreIndex; }
-    void setCoreIndex(int idx)
-    {
-        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
-        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
-        _coreIndex = qint16(idx);
-    }
-
-    quint8 revision() const { return _revision; }
-    void setRevision(quint8 rev)
-    {
-        Q_ASSERT(rev <= std::numeric_limits<quint8>::max());
-        _revision = quint8(rev);
-    }
-
-    /* If a property is a C++ type, then we store the minor
-     * version of this type.
-     * This is required to resolve property or signal revisions
-     * if this property is used as a grouped property.
-     *
-     * Test.qml
-     * property TextEdit someTextEdit: TextEdit {}
-     *
-     * Test {
-     *   someTextEdit.preeditText: "test" //revision 7
-     *   someTextEdit.onEditingFinished: console.log("test") //revision 6
-     * }
-     *
-     * To determine if these properties with revisions are available we need
-     * the minor version of TextEdit as imported in Test.qml.
-     *
-     */
-
-    quint8 typeMinorVersion() const { return _typeMinorVersion; }
-    void setTypeMinorVersion(quint8 rev)
-    {
-        Q_ASSERT(rev <= std::numeric_limits<quint8>::max());
-        _typeMinorVersion = quint8(rev);
-    }
-
-    QQmlPropertyCacheMethodArguments *arguments() const { return _arguments; }
-    void setArguments(QQmlPropertyCacheMethodArguments *args) { _arguments = args; }
-
-    int metaObjectOffset() const { return _metaObjectOffset; }
-    void setMetaObjectOffset(int off)
-    {
-        Q_ASSERT(off >= std::numeric_limits<qint16>::min());
-        Q_ASSERT(off <= std::numeric_limits<qint16>::max());
-        _metaObjectOffset = qint16(off);
-    }
-
-    StaticMetaCallFunction staticMetaCallFunction() const { return _staticMetaCallFunction; }
-    void trySetStaticMetaCallFunction(StaticMetaCallFunction f, unsigned relativePropertyIndex)
-    {
-        if (relativePropertyIndex < (1 << Flags::BitsLeftInFlags) - 1) {
-            _flags._otherBits = relativePropertyIndex;
-            _staticMetaCallFunction = f;
-        }
-    }
-    quint16 relativePropertyIndex() const { Q_ASSERT(hasStaticMetaCallFunction()); return _flags._otherBits; }
-
-private:
-    Flags _flags;
-    qint16 _coreIndex = 0;
-    quint16 _propType = 0;
-
-    // The notify index is in the range returned by QObjectPrivate::signalIndex().
-    // This is different from QMetaMethod::methodIndex().
-    qint16 _notifyIndex = 0;
-    qint16 _overrideIndex = 0;
-
-    quint8 _revision = 0;
-    quint8 _typeMinorVersion = 0;
-    qint16 _metaObjectOffset = 0;
-
-    QQmlPropertyCacheMethodArguments *_arguments = nullptr;
-    StaticMetaCallFunction _staticMetaCallFunction = nullptr;
-
-    friend class QQmlPropertyData;
-    friend class QQmlPropertyCache;
-};
-
-#if QT_POINTER_SIZE == 4
-Q_STATIC_ASSERT(sizeof(QQmlPropertyRawData) == 24);
-#else // QT_POINTER_SIZE == 8
-Q_STATIC_ASSERT(sizeof(QQmlPropertyRawData) == 32);
-#endif
-
-class QQmlPropertyData : public QQmlPropertyRawData
-{
-public:
-    enum WriteFlag {
-        BypassInterceptor = 0x01,
-        DontRemoveBinding = 0x02,
-        RemoveBindingOnAliasWrite = 0x04
-    };
-    Q_DECLARE_FLAGS(WriteFlags, WriteFlag)
-
-    inline QQmlPropertyData();
-    inline QQmlPropertyData(const QQmlPropertyRawData &);
-
-    inline bool operator==(const QQmlPropertyRawData &);
-
-    static Flags flagsForProperty(const QMetaProperty &);
-    void load(const QMetaProperty &);
-    void load(const QMetaMethod &);
-    QString name(QObject *) const;
-    QString name(const QMetaObject *) const;
-
-    void markAsOverrideOf(QQmlPropertyData *predecessor);
-
-    inline void readProperty(QObject *target, void *property) const
-    {
-        void *args[] = { property, nullptr };
-        readPropertyWithArgs(target, args);
-    }
-
-    inline void readPropertyWithArgs(QObject *target, void *args[]) const
-    {
-        if (hasStaticMetaCallFunction())
-            staticMetaCallFunction()(target, QMetaObject::ReadProperty, relativePropertyIndex(), args);
-        else if (isDirect())
-            target->qt_metacall(QMetaObject::ReadProperty, coreIndex(), args);
-        else
-            QMetaObject::metacall(target, QMetaObject::ReadProperty, coreIndex(), args);
-    }
-
-    bool writeProperty(QObject *target, void *value, WriteFlags flags) const
-    {
-        int status = -1;
-        void *argv[] = { value, nullptr, &status, &flags };
-        if (flags.testFlag(BypassInterceptor) && hasStaticMetaCallFunction())
-            staticMetaCallFunction()(target, QMetaObject::WriteProperty, relativePropertyIndex(), argv);
-        else if (flags.testFlag(BypassInterceptor) && isDirect())
-            target->qt_metacall(QMetaObject::WriteProperty, coreIndex(), argv);
-        else
-            QMetaObject::metacall(target, QMetaObject::WriteProperty, coreIndex(), argv);
-        return true;
-    }
-
-    static Flags defaultSignalFlags()
-    {
-        Flags f;
-        f.isSignal = true;
-        f.type = Flags::FunctionType;
-        f.isVMESignal = true;
-        return f;
-    }
-
-    static Flags defaultSlotFlags()
-    {
-        Flags f;
-        f.type = Flags::FunctionType;
-        f.isVMEFunction = true;
-        return f;
-    }
-
-private:
-    friend class QQmlPropertyCache;
-    void lazyLoad(const QMetaProperty &);
-    void lazyLoad(const QMetaMethod &);
-    bool notFullyResolved() const { return _flags.notFullyResolved; }
-};
-
-struct QQmlEnumValue
-{
-    QQmlEnumValue() {}
-    QQmlEnumValue(const QString &n, int v) : namedValue(n), value(v) {}
-    QString namedValue;
-    int value = -1;
-};
-
-struct QQmlEnumData
-{
-    QString name;
-    QVector<QQmlEnumValue> values;
-};
-
 class QQmlPropertyCacheMethodArguments;
+
 class Q_QML_PRIVATE_EXPORT QQmlPropertyCache : public QQmlRefCount
 {
 public:
@@ -558,170 +244,6 @@ private:
 
 typedef QQmlRefPointer<QQmlPropertyCache> QQmlPropertyCachePtr;
 
-// QQmlMetaObject serves as a wrapper around either QMetaObject or QQmlPropertyCache.
-// This is necessary as we delay creation of QMetaObject for synthesized QObjects, but
-// we don't want to needlessly generate QQmlPropertyCaches every time we encounter a
-// QObject type used in assignment or when we don't have a QQmlEngine etc.
-//
-// This class does NOT reference the propertycache.
-class QQmlEnginePrivate;
-class Q_QML_EXPORT QQmlMetaObject
-{
-public:
-    typedef QVarLengthArray<int, 9> ArgTypeStorage;
-
-    inline QQmlMetaObject();
-    inline QQmlMetaObject(QObject *);
-    inline QQmlMetaObject(const QMetaObject *);
-    inline QQmlMetaObject(QQmlPropertyCache *);
-    inline QQmlMetaObject(const QQmlMetaObject &);
-
-    inline QQmlMetaObject &operator=(const QQmlMetaObject &);
-
-    inline bool isNull() const;
-
-    inline const char *className() const;
-    inline int propertyCount() const;
-
-    inline bool hasMetaObject() const;
-    inline const QMetaObject *metaObject() const;
-
-    QQmlPropertyCache *propertyCache(QQmlEnginePrivate *) const;
-
-    int methodReturnType(const QQmlPropertyData &data, QByteArray *unknownTypeError) const;
-    int *methodParameterTypes(int index, ArgTypeStorage *argStorage,
-                              QByteArray *unknownTypeError) const;
-
-    static bool canConvert(const QQmlMetaObject &from, const QQmlMetaObject &to);
-
-    // static_metacall (on Gadgets) doesn't call the base implementation and therefore
-    // we need a helper to find the correct meta object and property/method index.
-    static void resolveGadgetMethodOrPropertyIndex(QMetaObject::Call type, const QMetaObject **metaObject, int *index);
-
-protected:
-    QBiPointer<QQmlPropertyCache, const QMetaObject> _m;
-    int *methodParameterTypes(const QMetaMethod &method, ArgTypeStorage *argStorage,
-                              QByteArray *unknownTypeError) const;
-
-};
-
-class QQmlObjectOrGadget: public QQmlMetaObject
-{
-public:
-    QQmlObjectOrGadget(QObject *obj)
-        : QQmlMetaObject(obj),
-          ptr(obj)
-    {}
-    QQmlObjectOrGadget(QQmlPropertyCache *propertyCache, void *gadget)
-        : QQmlMetaObject(propertyCache)
-        , ptr(gadget)
-    {}
-
-    void metacall(QMetaObject::Call type, int index, void **argv) const;
-
-private:
-    QBiPointer<QObject, void> ptr;
-
-protected:
-    QQmlObjectOrGadget(const QMetaObject* metaObject)
-        : QQmlMetaObject(metaObject)
-    {}
-
-};
-
-class QQmlStaticMetaObject : public QQmlObjectOrGadget {
-public:
-    QQmlStaticMetaObject(const QMetaObject* metaObject)
-        : QQmlObjectOrGadget(metaObject)
-    {}
-    int *constructorParameterTypes(int index, ArgTypeStorage *dummy, QByteArray *unknownTypeError) const;
-};
-
-QQmlPropertyRawData::Flags::Flags()
-    : _otherBits(0)
-    , isConstant(false)
-    , isWritable(false)
-    , isResettable(false)
-    , isAlias(false)
-    , isFinal(false)
-    , isOverridden(false)
-    , isDirect(false)
-    , type(OtherType)
-    , isVMEFunction(false)
-    , hasArguments(false)
-    , isSignal(false)
-    , isVMESignal(false)
-    , isV4Function(false)
-    , isSignalHandler(false)
-    , isOverload(false)
-    , isCloned(false)
-    , isConstructor(false)
-    , notFullyResolved(false)
-    , overrideIndexIsProperty(false)
-{}
-
-bool QQmlPropertyRawData::Flags::operator==(const QQmlPropertyRawData::Flags &other) const
-{
-    return isConstant == other.isConstant &&
-            isWritable == other.isWritable &&
-            isResettable == other.isResettable &&
-            isAlias == other.isAlias &&
-            isFinal == other.isFinal &&
-            isOverridden == other.isOverridden &&
-            type == other.type &&
-            isVMEFunction == other.isVMEFunction &&
-            hasArguments == other.hasArguments &&
-            isSignal == other.isSignal &&
-            isVMESignal == other.isVMESignal &&
-            isV4Function == other.isV4Function &&
-            isSignalHandler == other.isSignalHandler &&
-            isOverload == other.isOverload &&
-            isCloned == other.isCloned &&
-            isConstructor == other.isConstructor &&
-            notFullyResolved == other.notFullyResolved &&
-            overrideIndexIsProperty == other.overrideIndexIsProperty;
-}
-
-void QQmlPropertyRawData::Flags::copyPropertyTypeFlags(QQmlPropertyRawData::Flags from)
-{
-    switch (from.type) {
-    case QObjectDerivedType:
-    case EnumType:
-    case QListType:
-    case QmlBindingType:
-    case QJSValueType:
-    case V4HandleType:
-    case QVariantType:
-        type = from.type;
-    }
-}
-
-QQmlPropertyData::QQmlPropertyData()
-{
-    setCoreIndex(-1);
-    setPropType(0);
-    setNotifyIndex(-1);
-    setOverrideIndex(-1);
-    setRevision(0);
-    setMetaObjectOffset(-1);
-    setArguments(nullptr);
-    trySetStaticMetaCallFunction(nullptr, 0);
-}
-
-QQmlPropertyData::QQmlPropertyData(const QQmlPropertyRawData &d)
-{
-    *(static_cast<QQmlPropertyRawData *>(this)) = d;
-}
-
-bool QQmlPropertyData::operator==(const QQmlPropertyRawData &other)
-{
-    return flags() == other.flags() &&
-           propType() == other.propType() &&
-           coreIndex() == other.coreIndex() &&
-           notifyIndex() == other.notifyIndex() &&
-           revision() == other.revision();
-}
-
 inline QQmlPropertyData *QQmlPropertyCache::ensureResolved(QQmlPropertyData *p) const
 {
     if (p && Q_UNLIKELY(p->notFullyResolved()))
@@ -880,124 +402,6 @@ bool QQmlPropertyCache::callJSFactoryMethod(QObject *object, void **args) const
     return false;
 }
 
-QQmlMetaObject::QQmlMetaObject()
-{
-}
-
-QQmlMetaObject::QQmlMetaObject(QObject *o)
-{
-    if (o) {
-        QQmlData *ddata = QQmlData::get(o, false);
-        if (ddata && ddata->propertyCache) _m = ddata->propertyCache;
-        else _m = o->metaObject();
-    }
-}
-
-QQmlMetaObject::QQmlMetaObject(const QMetaObject *m)
-: _m(m)
-{
-}
-
-QQmlMetaObject::QQmlMetaObject(QQmlPropertyCache *m)
-: _m(m)
-{
-}
-
-QQmlMetaObject::QQmlMetaObject(const QQmlMetaObject &o)
-: _m(o._m)
-{
-}
-
-QQmlMetaObject &QQmlMetaObject::operator=(const QQmlMetaObject &o)
-{
-    _m = o._m;
-    return *this;
-}
-
-bool QQmlMetaObject::isNull() const
-{
-    return _m.isNull();
-}
-
-const char *QQmlMetaObject::className() const
-{
-    if (_m.isNull()) {
-        return nullptr;
-    } else if (_m.isT1()) {
-        return _m.asT1()->className();
-    } else {
-        return _m.asT2()->className();
-    }
-}
-
-int QQmlMetaObject::propertyCount() const
-{
-    if (_m.isNull()) {
-        return 0;
-    } else if (_m.isT1()) {
-        return _m.asT1()->propertyCount();
-    } else {
-        return _m.asT2()->propertyCount();
-    }
-}
-
-bool QQmlMetaObject::hasMetaObject() const
-{
-    return _m.isT2() || (!_m.isNull() && _m.asT1()->metaObject());
-}
-
-const QMetaObject *QQmlMetaObject::metaObject() const
-{
-    if (_m.isNull()) return nullptr;
-    if (_m.isT1()) return _m.asT1()->createMetaObject();
-    else return _m.asT2();
-}
-
-class QQmlPropertyCacheVector
-{
-public:
-    QQmlPropertyCacheVector() {}
-    QQmlPropertyCacheVector(QQmlPropertyCacheVector &&other)
-        : data(std::move(other.data)) {}
-    QQmlPropertyCacheVector &operator=(QQmlPropertyCacheVector &&other) {
-        QVector<QFlagPointer<QQmlPropertyCache>> moved(std::move(other.data));
-        data.swap(moved);
-        return *this;
-    }
-
-    ~QQmlPropertyCacheVector() { clear(); }
-    void resize(int size) { return data.resize(size); }
-    int count() const { return data.count(); }
-    void clear()
-    {
-        for (int i = 0; i < data.count(); ++i) {
-            if (QQmlPropertyCache *cache = data.at(i).data())
-                cache->release();
-        }
-        data.clear();
-    }
-
-    void append(QQmlPropertyCache *cache) { cache->addref(); data.append(cache); }
-    QQmlPropertyCache *at(int index) const { return data.at(index).data(); }
-    void set(int index, const QQmlRefPointer<QQmlPropertyCache> &replacement) {
-        if (QQmlPropertyCache *oldCache = data.at(index).data()) {
-            if (replacement.data() == oldCache)
-                return;
-            oldCache->release();
-        }
-        data[index] = replacement.data();
-        replacement->addref();
-    }
-
-    void setNeedsVMEMetaObject(int index) { data[index].setFlag(); }
-    bool needsVMEMetaObject(int index) const { return data.at(index).flag(); }
-private:
-    Q_DISABLE_COPY(QQmlPropertyCacheVector)
-    QVector<QFlagPointer<QQmlPropertyCache>> data;
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(QQmlPropertyData::WriteFlags)
-
 QT_END_NAMESPACE
 
 #endif // QQMLPROPERTYCACHE_P_H
diff --git a/src/qml/qml/qqmlpropertycachemethodarguments_p.h b/src/qml/qml/qqmlpropertycachemethodarguments_p.h
new file mode 100644
index 0000000000..62f09bdfff
--- /dev/null
+++ b/src/qml/qml/qqmlpropertycachemethodarguments_p.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLPROPERTYCACHEMETODARGUMENTS_P_H
+#define QQMLPROPERTYCACHEMETODARGUMENTS_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qlist.h>
+#include <QtCore/qbytearray.h>
+
+QT_BEGIN_NAMESPACE
+
+class QString;
+class QQmlPropertyCacheMethodArguments
+{
+public:
+    QQmlPropertyCacheMethodArguments *next;
+
+    //for signal handler rewrites
+    QString *signalParameterStringForJS;
+    int parameterError:1;
+    int argumentsValid:1;
+
+    QList<QByteArray> *names;
+
+    int arguments[1];
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLPROPERTYCACHEMETODARGUMENTS_P_H
diff --git a/src/qml/qml/qqmlpropertycachevector_p.h b/src/qml/qml/qqmlpropertycachevector_p.h
new file mode 100644
index 0000000000..1dff7c61a6
--- /dev/null
+++ b/src/qml/qml/qqmlpropertycachevector_p.h
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLPROPERTYCACHEVECTOR_P_H
+#define QQMLPROPERTYCACHEVECTOR_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qflagpointer_p.h>
+#include <private/qqmlpropertycache_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQmlPropertyCacheVector
+{
+public:
+    QQmlPropertyCacheVector() {}
+    QQmlPropertyCacheVector(QQmlPropertyCacheVector &&other)
+        : data(std::move(other.data)) {}
+    QQmlPropertyCacheVector &operator=(QQmlPropertyCacheVector &&other) {
+        QVector<QFlagPointer<QQmlPropertyCache>> moved(std::move(other.data));
+        data.swap(moved);
+        return *this;
+    }
+
+    ~QQmlPropertyCacheVector() { clear(); }
+    void resize(int size) { return data.resize(size); }
+    int count() const { return data.count(); }
+    void clear()
+    {
+        for (int i = 0; i < data.count(); ++i) {
+            if (QQmlPropertyCache *cache = data.at(i).data())
+                cache->release();
+        }
+        data.clear();
+    }
+
+    void append(QQmlPropertyCache *cache) { cache->addref(); data.append(cache); }
+    QQmlPropertyCache *at(int index) const { return data.at(index).data(); }
+    void set(int index, const QQmlRefPointer<QQmlPropertyCache> &replacement) {
+        if (QQmlPropertyCache *oldCache = data.at(index).data()) {
+            if (replacement.data() == oldCache)
+                return;
+            oldCache->release();
+        }
+        data[index] = replacement.data();
+        replacement->addref();
+    }
+
+    void setNeedsVMEMetaObject(int index) { data[index].setFlag(); }
+    bool needsVMEMetaObject(int index) const { return data.at(index).flag(); }
+private:
+    Q_DISABLE_COPY(QQmlPropertyCacheVector)
+    QVector<QFlagPointer<QQmlPropertyCache>> data;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLPROPERTYCACHEVECTOR_P_H
diff --git a/src/qml/qml/qqmlpropertydata_p.h b/src/qml/qml/qqmlpropertydata_p.h
new file mode 100644
index 0000000000..a292bcc769
--- /dev/null
+++ b/src/qml/qml/qqmlpropertydata_p.h
@@ -0,0 +1,164 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLPROPERTYDATA_P_H
+#define QQMLPROPERTYDATA_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qqmlpropertyrawdata_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQmlPropertyData : public QQmlPropertyRawData
+{
+public:
+    enum WriteFlag {
+        BypassInterceptor = 0x01,
+        DontRemoveBinding = 0x02,
+        RemoveBindingOnAliasWrite = 0x04
+    };
+    Q_DECLARE_FLAGS(WriteFlags, WriteFlag)
+
+    inline QQmlPropertyData();
+    inline QQmlPropertyData(const QQmlPropertyRawData &);
+
+    inline bool operator==(const QQmlPropertyRawData &);
+
+    static Flags flagsForProperty(const QMetaProperty &);
+    void load(const QMetaProperty &);
+    void load(const QMetaMethod &);
+    QString name(QObject *) const;
+    QString name(const QMetaObject *) const;
+
+    void markAsOverrideOf(QQmlPropertyData *predecessor);
+
+    inline void readProperty(QObject *target, void *property) const
+    {
+        void *args[] = { property, nullptr };
+        readPropertyWithArgs(target, args);
+    }
+
+    inline void readPropertyWithArgs(QObject *target, void *args[]) const
+    {
+        if (hasStaticMetaCallFunction())
+            staticMetaCallFunction()(target, QMetaObject::ReadProperty, relativePropertyIndex(), args);
+        else if (isDirect())
+            target->qt_metacall(QMetaObject::ReadProperty, coreIndex(), args);
+        else
+            QMetaObject::metacall(target, QMetaObject::ReadProperty, coreIndex(), args);
+    }
+
+    bool writeProperty(QObject *target, void *value, WriteFlags flags) const
+    {
+        int status = -1;
+        void *argv[] = { value, nullptr, &status, &flags };
+        if (flags.testFlag(BypassInterceptor) && hasStaticMetaCallFunction())
+            staticMetaCallFunction()(target, QMetaObject::WriteProperty, relativePropertyIndex(), argv);
+        else if (flags.testFlag(BypassInterceptor) && isDirect())
+            target->qt_metacall(QMetaObject::WriteProperty, coreIndex(), argv);
+        else
+            QMetaObject::metacall(target, QMetaObject::WriteProperty, coreIndex(), argv);
+        return true;
+    }
+
+    static Flags defaultSignalFlags()
+    {
+        Flags f;
+        f.isSignal = true;
+        f.type = Flags::FunctionType;
+        f.isVMESignal = true;
+        return f;
+    }
+
+    static Flags defaultSlotFlags()
+    {
+        Flags f;
+        f.type = Flags::FunctionType;
+        f.isVMEFunction = true;
+        return f;
+    }
+
+private:
+    friend class QQmlPropertyCache;
+    void lazyLoad(const QMetaProperty &);
+    void lazyLoad(const QMetaMethod &);
+    bool notFullyResolved() const { return _flags.notFullyResolved; }
+};
+
+QQmlPropertyData::QQmlPropertyData()
+{
+    setCoreIndex(-1);
+    setPropType(0);
+    setNotifyIndex(-1);
+    setOverrideIndex(-1);
+    setRevision(0);
+    setMetaObjectOffset(-1);
+    setArguments(nullptr);
+    trySetStaticMetaCallFunction(nullptr, 0);
+}
+
+QQmlPropertyData::QQmlPropertyData(const QQmlPropertyRawData &d)
+{
+    *(static_cast<QQmlPropertyRawData *>(this)) = d;
+}
+
+bool QQmlPropertyData::operator==(const QQmlPropertyRawData &other)
+{
+    return flags() == other.flags() &&
+            propType() == other.propType() &&
+            coreIndex() == other.coreIndex() &&
+            notifyIndex() == other.notifyIndex() &&
+            revision() == other.revision();
+}
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QQmlPropertyData::WriteFlags)
+
+QT_END_NAMESPACE
+
+#endif // QQMLPROPERTYDATA_P_H
diff --git a/src/qml/qml/qqmlpropertyrawdata_p.h b/src/qml/qml/qqmlpropertyrawdata_p.h
new file mode 100644
index 0000000000..833c0f6ad0
--- /dev/null
+++ b/src/qml/qml/qqmlpropertyrawdata_p.h
@@ -0,0 +1,341 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLPROPERTYRAWDATA_P_H
+#define QQMLPROPERTYRAWDATA_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qobject_p.h>
+
+QT_BEGIN_NAMESPACE
+
+// We have this somewhat awful split between RawData and Data so that RawData can be
+// used in unions.  In normal code, you should always use Data which initializes RawData
+// to an invalid state on construction.
+// ### We should be able to remove this split nowadays
+class QQmlPropertyCacheMethodArguments;
+class QQmlPropertyRawData
+{
+public:
+    typedef QObjectPrivate::StaticMetaCallFunction StaticMetaCallFunction;
+
+    struct Flags {
+        enum Types {
+            OtherType            = 0,
+            FunctionType         = 1, // Is an invokable
+            QObjectDerivedType   = 2, // Property type is a QObject* derived type
+            EnumType             = 3, // Property type is an enum
+            QListType            = 4, // Property type is a QML list
+            QmlBindingType       = 5, // Property type is a QQmlBinding*
+            QJSValueType         = 6, // Property type is a QScriptValue
+            V4HandleType         = 7, // Property type is a QQmlV4Handle
+            VarPropertyType      = 8, // Property type is a "var" property of VMEMO
+            QVariantType         = 9  // Property is a QVariant
+        };
+
+        // The _otherBits (which "pad" the Flags struct to align it nicely) are used
+        // to store the relative property index. It will only get used when said index fits. See
+        // trySetStaticMetaCallFunction for details.
+        // (Note: this padding is done here, because certain compilers have surprising behavior
+        // when an enum is declared in-between two bit fields.)
+        enum { BitsLeftInFlags = 10 };
+        unsigned _otherBits       : BitsLeftInFlags; // align to 32 bits
+
+        // Can apply to all properties, except IsFunction
+        unsigned isConstant       : 1; // Has CONST flag
+        unsigned isWritable       : 1; // Has WRITE function
+        unsigned isResettable     : 1; // Has RESET function
+        unsigned isAlias          : 1; // Is a QML alias to another property
+        unsigned isFinal          : 1; // Has FINAL flag
+        unsigned isOverridden     : 1; // Is overridden by a extension property
+        unsigned isDirect         : 1; // Exists on a C++ QMetaObject
+
+        unsigned type             : 4; // stores an entry of Types
+
+        // Apply only to IsFunctions
+        unsigned isVMEFunction    : 1; // Function was added by QML
+        unsigned hasArguments     : 1; // Function takes arguments
+        unsigned isSignal         : 1; // Function is a signal
+        unsigned isVMESignal      : 1; // Signal was added by QML
+        unsigned isV4Function     : 1; // Function takes QQmlV4Function* args
+        unsigned isSignalHandler  : 1; // Function is a signal handler
+        unsigned isOverload       : 1; // Function is an overload of another function
+        unsigned isCloned         : 1; // The function was marked as cloned
+        unsigned isConstructor    : 1; // The function was marked is a constructor
+
+        // Internal QQmlPropertyCache flags
+        unsigned notFullyResolved : 1; // True if the type data is to be lazily resolved
+        unsigned overrideIndexIsProperty: 1;
+
+        inline Flags();
+        inline bool operator==(const Flags &other) const;
+        inline void copyPropertyTypeFlags(Flags from);
+    };
+
+    Flags flags() const { return _flags; }
+    void setFlags(Flags f)
+    {
+        unsigned otherBits = _flags._otherBits;
+        _flags = f;
+        _flags._otherBits = otherBits;
+    }
+
+    bool isValid() const { return coreIndex() != -1; }
+
+    bool isConstant() const { return _flags.isConstant; }
+    bool isWritable() const { return _flags.isWritable; }
+    void setWritable(bool onoff) { _flags.isWritable = onoff; }
+    bool isResettable() const { return _flags.isResettable; }
+    bool isAlias() const { return _flags.isAlias; }
+    bool isFinal() const { return _flags.isFinal; }
+    bool isOverridden() const { return _flags.isOverridden; }
+    bool isDirect() const { return _flags.isDirect; }
+    bool hasStaticMetaCallFunction() const { return staticMetaCallFunction() != nullptr; }
+    bool isFunction() const { return _flags.type == Flags::FunctionType; }
+    bool isQObject() const { return _flags.type == Flags::QObjectDerivedType; }
+    bool isEnum() const { return _flags.type == Flags::EnumType; }
+    bool isQList() const { return _flags.type == Flags::QListType; }
+    bool isQmlBinding() const { return _flags.type == Flags::QmlBindingType; }
+    bool isQJSValue() const { return _flags.type == Flags::QJSValueType; }
+    bool isV4Handle() const { return _flags.type == Flags::V4HandleType; }
+    bool isVarProperty() const { return _flags.type == Flags::VarPropertyType; }
+    bool isQVariant() const { return _flags.type == Flags::QVariantType; }
+    bool isVMEFunction() const { return _flags.isVMEFunction; }
+    bool hasArguments() const { return _flags.hasArguments; }
+    bool isSignal() const { return _flags.isSignal; }
+    bool isVMESignal() const { return _flags.isVMESignal; }
+    bool isV4Function() const { return _flags.isV4Function; }
+    bool isSignalHandler() const { return _flags.isSignalHandler; }
+    bool isOverload() const { return _flags.isOverload; }
+    void setOverload(bool onoff) { _flags.isOverload = onoff; }
+    bool isCloned() const { return _flags.isCloned; }
+    bool isConstructor() const { return _flags.isConstructor; }
+
+    bool hasOverride() const { return overrideIndex() >= 0; }
+    bool hasRevision() const { return revision() != 0; }
+
+    bool isFullyResolved() const { return !_flags.notFullyResolved; }
+
+    int propType() const { Q_ASSERT(isFullyResolved()); return _propType; }
+    void setPropType(int pt)
+    {
+        Q_ASSERT(pt >= 0);
+        Q_ASSERT(pt <= std::numeric_limits<qint16>::max());
+        _propType = quint16(pt);
+    }
+
+    int notifyIndex() const { return _notifyIndex; }
+    void setNotifyIndex(int idx)
+    {
+        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
+        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
+        _notifyIndex = qint16(idx);
+    }
+
+    bool overrideIndexIsProperty() const { return _flags.overrideIndexIsProperty; }
+    void setOverrideIndexIsProperty(bool onoff) { _flags.overrideIndexIsProperty = onoff; }
+
+    int overrideIndex() const { return _overrideIndex; }
+    void setOverrideIndex(int idx)
+    {
+        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
+        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
+        _overrideIndex = qint16(idx);
+    }
+
+    int coreIndex() const { return _coreIndex; }
+    void setCoreIndex(int idx)
+    {
+        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
+        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
+        _coreIndex = qint16(idx);
+    }
+
+    quint8 revision() const { return _revision; }
+    void setRevision(quint8 rev)
+    {
+        Q_ASSERT(rev <= std::numeric_limits<quint8>::max());
+        _revision = quint8(rev);
+    }
+
+    /* If a property is a C++ type, then we store the minor
+     * version of this type.
+     * This is required to resolve property or signal revisions
+     * if this property is used as a grouped property.
+     *
+     * Test.qml
+     * property TextEdit someTextEdit: TextEdit {}
+     *
+     * Test {
+     *   someTextEdit.preeditText: "test" //revision 7
+     *   someTextEdit.onEditingFinished: console.log("test") //revision 6
+     * }
+     *
+     * To determine if these properties with revisions are available we need
+     * the minor version of TextEdit as imported in Test.qml.
+     *
+     */
+
+    quint8 typeMinorVersion() const { return _typeMinorVersion; }
+    void setTypeMinorVersion(quint8 rev)
+    {
+        Q_ASSERT(rev <= std::numeric_limits<quint8>::max());
+        _typeMinorVersion = quint8(rev);
+    }
+
+    QQmlPropertyCacheMethodArguments *arguments() const { return _arguments; }
+    void setArguments(QQmlPropertyCacheMethodArguments *args) { _arguments = args; }
+
+    int metaObjectOffset() const { return _metaObjectOffset; }
+    void setMetaObjectOffset(int off)
+    {
+        Q_ASSERT(off >= std::numeric_limits<qint16>::min());
+        Q_ASSERT(off <= std::numeric_limits<qint16>::max());
+        _metaObjectOffset = qint16(off);
+    }
+
+    StaticMetaCallFunction staticMetaCallFunction() const { return _staticMetaCallFunction; }
+    void trySetStaticMetaCallFunction(StaticMetaCallFunction f, unsigned relativePropertyIndex)
+    {
+        if (relativePropertyIndex < (1 << Flags::BitsLeftInFlags) - 1) {
+            _flags._otherBits = relativePropertyIndex;
+            _staticMetaCallFunction = f;
+        }
+    }
+    quint16 relativePropertyIndex() const { Q_ASSERT(hasStaticMetaCallFunction()); return _flags._otherBits; }
+
+private:
+    Flags _flags;
+    qint16 _coreIndex = 0;
+    quint16 _propType = 0;
+
+    // The notify index is in the range returned by QObjectPrivate::signalIndex().
+    // This is different from QMetaMethod::methodIndex().
+    qint16 _notifyIndex = 0;
+    qint16 _overrideIndex = 0;
+
+    quint8 _revision = 0;
+    quint8 _typeMinorVersion = 0;
+    qint16 _metaObjectOffset = 0;
+
+    QQmlPropertyCacheMethodArguments *_arguments = nullptr;
+    StaticMetaCallFunction _staticMetaCallFunction = nullptr;
+
+    friend class QQmlPropertyData;
+    friend class QQmlPropertyCache;
+};
+
+#if QT_POINTER_SIZE == 4
+    Q_STATIC_ASSERT(sizeof(QQmlPropertyRawData) == 24);
+#else // QT_POINTER_SIZE == 8
+    Q_STATIC_ASSERT(sizeof(QQmlPropertyRawData) == 32);
+#endif
+
+QQmlPropertyRawData::Flags::Flags()
+    : _otherBits(0)
+    , isConstant(false)
+    , isWritable(false)
+    , isResettable(false)
+    , isAlias(false)
+    , isFinal(false)
+    , isOverridden(false)
+    , isDirect(false)
+    , type(OtherType)
+    , isVMEFunction(false)
+    , hasArguments(false)
+    , isSignal(false)
+    , isVMESignal(false)
+    , isV4Function(false)
+    , isSignalHandler(false)
+    , isOverload(false)
+    , isCloned(false)
+    , isConstructor(false)
+    , notFullyResolved(false)
+    , overrideIndexIsProperty(false)
+{}
+
+bool QQmlPropertyRawData::Flags::operator==(const QQmlPropertyRawData::Flags &other) const
+{
+    return isConstant == other.isConstant &&
+            isWritable == other.isWritable &&
+            isResettable == other.isResettable &&
+            isAlias == other.isAlias &&
+            isFinal == other.isFinal &&
+            isOverridden == other.isOverridden &&
+            type == other.type &&
+            isVMEFunction == other.isVMEFunction &&
+            hasArguments == other.hasArguments &&
+            isSignal == other.isSignal &&
+            isVMESignal == other.isVMESignal &&
+            isV4Function == other.isV4Function &&
+            isSignalHandler == other.isSignalHandler &&
+            isOverload == other.isOverload &&
+            isCloned == other.isCloned &&
+            isConstructor == other.isConstructor &&
+            notFullyResolved == other.notFullyResolved &&
+            overrideIndexIsProperty == other.overrideIndexIsProperty;
+}
+
+void QQmlPropertyRawData::Flags::copyPropertyTypeFlags(QQmlPropertyRawData::Flags from)
+{
+    switch (from.type) {
+    case QObjectDerivedType:
+    case EnumType:
+    case QListType:
+    case QmlBindingType:
+    case QJSValueType:
+    case V4HandleType:
+    case QVariantType:
+        type = from.type;
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif // QQMLPROPERTYRAWDATA_P_H
diff --git a/src/qml/qml/qqmlstaticmetaobject.cpp b/src/qml/qml/qqmlstaticmetaobject.cpp
new file mode 100644
index 0000000000..218d0134fd
--- /dev/null
+++ b/src/qml/qml/qqmlstaticmetaobject.cpp
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** 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 "qqmlstaticmetaobject_p.h"
+
+QT_BEGIN_NAMESPACE
+
+int *QQmlStaticMetaObject::constructorParameterTypes(int index, ArgTypeStorage *dummy,
+                                                     QByteArray *unknownTypeError) const
+{
+    QMetaMethod m = _m.asT2()->constructor(index);
+    return methodParameterTypes(m, dummy, unknownTypeError);
+}
+
+QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlstaticmetaobject_p.h b/src/qml/qml/qqmlstaticmetaobject_p.h
new file mode 100644
index 0000000000..e1ca496080
--- /dev/null
+++ b/src/qml/qml/qqmlstaticmetaobject_p.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef QQMLSTATICMETAOBJECT_P_H
+#define QQMLSTATICMETAOBJECT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qqmlobjectorgadget_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQmlStaticMetaObject : public QQmlObjectOrGadget {
+public:
+    QQmlStaticMetaObject(const QMetaObject* metaObject)
+        : QQmlObjectOrGadget(metaObject)
+    {}
+    int *constructorParameterTypes(int index, ArgTypeStorage *dummy, QByteArray *unknownTypeError) const;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLSTATICMETAOBJECT_P_H
diff --git a/src/qml/qml/qqmltypewrapper.cpp b/src/qml/qml/qqmltypewrapper.cpp
index 4089a7f030..3ec828ea2d 100644
--- a/src/qml/qml/qqmltypewrapper.cpp
+++ b/src/qml/qml/qqmltypewrapper.cpp
@@ -42,6 +42,7 @@
 
 #include <private/qqmlengine_p.h>
 #include <private/qqmlcontext_p.h>
+#include <private/qqmlmetaobject_p.h>
 
 #include <private/qjsvalue_p.h>
 #include <private/qv4functionobject_p.h>
diff --git a/src/qml/qml/qqmlvmemetaobject_p.h b/src/qml/qml/qqmlvmemetaobject_p.h
index dbcc9d2884..87dc9fb0b2 100644
--- a/src/qml/qml/qqmlvmemetaobject_p.h
+++ b/src/qml/qml/qqmlvmemetaobject_p.h
@@ -65,7 +65,6 @@
 
 #include "qqmlguard_p.h"
 #include "qqmlcontext_p.h"
-#include "qqmlpropertycache_p.h"
 
 #include <private/qv8engine_p.h>
 #include <private/qflagpointer_p.h>