Dissolve QQmlPropertyRawData

There is no reason anymore to split the class in two parts.

Change-Id: Iabef7acec1db7afc0ed4e89e1fd5b78699dc0847
Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>

5 files changed, 307 insertions, 400 deletions

diff --git a/src/qml/qml/qml.pri b/src/qml/qml/qml.pri
index 0895e5ae68..9f79bfacdf 100644
--- a/src/qml/qml/qml.pri
+++ b/src/qml/qml/qml.pri
@@ -102,7 +102,6 @@ HEADERS += \
     $$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 \
diff --git a/src/qml/qml/qqmlpropertycache.cpp b/src/qml/qml/qqmlpropertycache.cpp
index 678b78ed17..fb8136abb4 100644
--- a/src/qml/qml/qqmlpropertycache.cpp
+++ b/src/qml/qml/qqmlpropertycache.cpp
@@ -136,12 +136,12 @@ void QQmlPropertyData::lazyLoad(const QMetaProperty &p)
     int type = static_cast<int>(p.type());
     if (type == QMetaType::QObjectStar) {
         setPropType(type);
-        _flags.type = Flags::QObjectDerivedType;
+        m_flags.type = Flags::QObjectDerivedType;
     } else if (type == QMetaType::QVariant) {
         setPropType(type);
-        _flags.type = Flags::QVariantType;
+        m_flags.type = Flags::QVariantType;
     } else if (type == QVariant::UserType || type == -1) {
-        _flags.notFullyResolved = true;
+        m_flags.notFullyResolved = true;
     } else {
         setPropType(type);
     }
@@ -153,7 +153,7 @@ void QQmlPropertyData::load(const QMetaProperty &p)
     setCoreIndex(p.propertyIndex());
     setNotifyIndex(QMetaObjectPrivate::signalIndex(p.notifySignal()));
     setFlags(fastFlagsForProperty(p));
-    flagsForPropertyType(propType(), _flags);
+    flagsForPropertyType(propType(), m_flags);
     Q_ASSERT(p.revision() <= Q_INT16_MAX);
     setRevision(p.revision());
 }
@@ -165,23 +165,23 @@ void QQmlPropertyData::load(const QMetaMethod &m)
 
     setPropType(m.returnType());
 
-    _flags.type = Flags::FunctionType;
+    m_flags.type = Flags::FunctionType;
     if (m.methodType() == QMetaMethod::Signal)
-        _flags.isSignal = true;
+        m_flags.isSignal = true;
     else if (m.methodType() == QMetaMethod::Constructor) {
-        _flags.isConstructor = true;
+        m_flags.isConstructor = true;
         setPropType(QMetaType::QObjectStar);
     }
 
     if (m.parameterCount()) {
-        _flags.hasArguments = true;
+        m_flags.hasArguments = true;
         if ((m.parameterCount() == 1) && (m.parameterTypes().constFirst() == "QQmlV4Function*")) {
-            _flags.isV4Function = true;
+            m_flags.isV4Function = true;
         }
     }
 
     if (m.attributes() & QMetaMethod::Cloned)
-        _flags.isCloned = true;
+        m_flags.isCloned = true;
 
     Q_ASSERT(m.revision() <= Q_INT16_MAX);
     setRevision(m.revision());
@@ -192,11 +192,11 @@ void QQmlPropertyData::lazyLoad(const QMetaMethod &m)
     setCoreIndex(m.methodIndex());
     setPropType(QMetaType::Void);
     setArguments(nullptr);
-    _flags.type = Flags::FunctionType;
+    m_flags.type = Flags::FunctionType;
     if (m.methodType() == QMetaMethod::Signal)
-        _flags.isSignal = true;
+        m_flags.isSignal = true;
     else if (m.methodType() == QMetaMethod::Constructor) {
-        _flags.isConstructor = true;
+        m_flags.isConstructor = true;
         setPropType(QMetaType::QObjectStar);
     }
 
@@ -204,19 +204,19 @@ void QQmlPropertyData::lazyLoad(const QMetaMethod &m)
     if (!returnType)
         returnType = "\0";
     if ((*returnType != 'v') || (qstrcmp(returnType+1, "oid") != 0)) {
-        _flags.notFullyResolved = true;
+        m_flags.notFullyResolved = true;
     }
 
     const int paramCount = m.parameterCount();
     if (paramCount) {
-        _flags.hasArguments = true;
+        m_flags.hasArguments = true;
         if ((paramCount == 1) && (m.parameterTypes().constFirst() == "QQmlV4Function*")) {
-            _flags.isV4Function = true;
+            m_flags.isV4Function = true;
         }
     }
 
     if (m.attributes() & QMetaMethod::Cloned)
-        _flags.isCloned = true;
+        m_flags.isCloned = true;
 
     Q_ASSERT(m.revision() <= Q_INT16_MAX);
     setRevision(m.revision());
@@ -344,7 +344,7 @@ void QQmlPropertyCache::appendSignal(const QString &name, QQmlPropertyData::Flag
     data.setArguments(nullptr);
 
     QQmlPropertyData handler = data;
-    handler._flags.isSignalHandler = true;
+    handler.m_flags.isSignalHandler = true;
 
     if (types) {
         int argumentCount = *types;
@@ -542,7 +542,7 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
             data->setFlags(methodFlags);
 
         data->lazyLoad(m);
-        data->_flags.isDirect = !dynamicMetaObject;
+        data->m_flags.isDirect = !dynamicMetaObject;
 
         Q_ASSERT((allowedRevisionCache.count() - 1) < Q_INT16_MAX);
         data->setMetaObjectOffset(allowedRevisionCache.count() - 1);
@@ -550,7 +550,7 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
         if (data->isSignal()) {
             sigdata = &signalHandlerIndexCache[signalHandlerIndex - signalHandlerIndexCacheStart];
             *sigdata = *data;
-            sigdata->_flags.isSignalHandler = true;
+            sigdata->m_flags.isSignalHandler = true;
         }
 
         QQmlPropertyData *old = nullptr;
@@ -592,7 +592,7 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
         if (old) {
             // We only overload methods in the same class, exactly like C++
             if (old->isFunction() && old->coreIndex() >= methodOffset)
-                data->_flags.isOverload = true;
+                data->m_flags.isOverload = true;
 
             data->markAsOverrideOf(old);
         }
@@ -623,7 +623,7 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
         data->lazyLoad(p);
         data->setTypeMinorVersion(typeMinorVersion);
 
-        data->_flags.isDirect = !dynamicMetaObject;
+        data->m_flags.isDirect = !dynamicMetaObject;
 
         Q_ASSERT((allowedRevisionCache.count() - 1) < Q_INT16_MAX);
         data->setMetaObjectOffset(allowedRevisionCache.count() - 1);
@@ -649,7 +649,7 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
         }
 
         if (isGadget) // always dispatch over a 'normal' meta-call so the QQmlValueType can intercept
-            data->_flags.isDirect = false;
+            data->m_flags.isDirect = false;
         else
             data->trySetStaticMetaCallFunction(metaObject->d.static_metacall, ii - propOffset);
         if (old)
@@ -660,7 +660,7 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
 void QQmlPropertyCache::resolve(QQmlPropertyData *data) const
 {
     Q_ASSERT(data->notFullyResolved());
-    data->_flags.notFullyResolved = false;
+    data->m_flags.notFullyResolved = false;
 
     const QMetaObject *mo = firstCppMetaObject();
     if (data->isFunction()) {
@@ -695,7 +695,7 @@ void QQmlPropertyCache::resolve(QQmlPropertyData *data) const
                 data->setPropType(registerResult == -1 ? QMetaType::UnknownType : registerResult);
             }
         }
-        flagsForPropertyType(data->propType(), data->_flags);
+        flagsForPropertyType(data->propType(), data->m_flags);
     }
 }
 
@@ -872,7 +872,7 @@ void QQmlPropertyData::markAsOverrideOf(QQmlPropertyData *predecessor)
     setOverrideIndexIsProperty(!predecessor->isFunction());
     setOverrideIndex(predecessor->coreIndex());
 
-    predecessor->_flags.isOverridden = true;
+    predecessor->m_flags.isOverridden = true;
 }
 
 QQmlPropertyCacheMethodArguments *QQmlPropertyCache::createArgumentsObject(int argc, const QList<QByteArray> &names)
diff --git a/src/qml/qml/qqmlpropertycache_p.h b/src/qml/qml/qqmlpropertycache_p.h
index d74414bf67..72692ee522 100644
--- a/src/qml/qml/qqmlpropertycache_p.h
+++ b/src/qml/qml/qqmlpropertycache_p.h
@@ -89,19 +89,19 @@ public:
     QQmlPropertyCache *copy();
 
     QQmlPropertyCache *copyAndAppend(const QMetaObject *,
-                QQmlPropertyRawData::Flags propertyFlags = QQmlPropertyData::Flags(),
-                QQmlPropertyRawData::Flags methodFlags = QQmlPropertyData::Flags(),
-                QQmlPropertyRawData::Flags signalFlags = QQmlPropertyData::Flags());
+                QQmlPropertyData::Flags propertyFlags = QQmlPropertyData::Flags(),
+                QQmlPropertyData::Flags methodFlags = QQmlPropertyData::Flags(),
+                QQmlPropertyData::Flags signalFlags = QQmlPropertyData::Flags());
     QQmlPropertyCache *copyAndAppend(const QMetaObject *, int typeMinorVersion,
-                QQmlPropertyRawData::Flags propertyFlags = QQmlPropertyData::Flags(),
-                QQmlPropertyRawData::Flags methodFlags = QQmlPropertyData::Flags(),
-                QQmlPropertyRawData::Flags signalFlags = QQmlPropertyData::Flags());
+                QQmlPropertyData::Flags propertyFlags = QQmlPropertyData::Flags(),
+                QQmlPropertyData::Flags methodFlags = QQmlPropertyData::Flags(),
+                QQmlPropertyData::Flags signalFlags = QQmlPropertyData::Flags());
 
     QQmlPropertyCache *copyAndReserve(int propertyCount,
                                       int methodCount, int signalCount, int enumCount);
-    void appendProperty(const QString &, QQmlPropertyRawData::Flags flags, int coreIndex,
+    void appendProperty(const QString &, QQmlPropertyData::Flags flags, int coreIndex,
                         int propType, int revision, int notifyIndex);
-    void appendSignal(const QString &, QQmlPropertyRawData::Flags, int coreIndex,
+    void appendSignal(const QString &, QQmlPropertyData::Flags, int coreIndex,
                       const int *types = nullptr, const QList<QByteArray> &names = QList<QByteArray>());
     void appendMethod(const QString &, QQmlPropertyData::Flags flags, int coreIndex,
                       const QList<QByteArray> &names = QList<QByteArray>());
@@ -187,9 +187,9 @@ private:
     inline QQmlPropertyCache *copy(int reserve);
 
     void append(const QMetaObject *, int typeMinorVersion,
-                QQmlPropertyRawData::Flags propertyFlags = QQmlPropertyRawData::Flags(),
-                QQmlPropertyRawData::Flags methodFlags = QQmlPropertyData::Flags(),
-                QQmlPropertyRawData::Flags signalFlags = QQmlPropertyData::Flags());
+                QQmlPropertyData::Flags propertyFlags = QQmlPropertyData::Flags(),
+                QQmlPropertyData::Flags methodFlags = QQmlPropertyData::Flags(),
+                QQmlPropertyData::Flags signalFlags = QQmlPropertyData::Flags());
 
     QQmlPropertyCacheMethodArguments *createArgumentsObject(int count, const QList<QByteArray> &names);
 
diff --git a/src/qml/qml/qqmlpropertydata_p.h b/src/qml/qml/qqmlpropertydata_p.h
index a292bcc769..dec696226e 100644
--- a/src/qml/qml/qqmlpropertydata_p.h
+++ b/src/qml/qml/qqmlpropertydata_p.h
@@ -51,11 +51,12 @@
 // We mean it.
 //
 
-#include <private/qqmlpropertyrawdata_p.h>
+#include <private/qobject_p.h>
 
 QT_BEGIN_NAMESPACE
 
-class QQmlPropertyData : public QQmlPropertyRawData
+class QQmlPropertyCacheMethodArguments;
+class QQmlPropertyData
 {
 public:
     enum WriteFlag {
@@ -65,10 +66,193 @@ public:
     };
     Q_DECLARE_FLAGS(WriteFlags, WriteFlag)
 
-    inline QQmlPropertyData();
-    inline QQmlPropertyData(const QQmlPropertyRawData &);
+    typedef QObjectPrivate::StaticMetaCallFunction StaticMetaCallFunction;
 
-    inline bool operator==(const QQmlPropertyRawData &);
+    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
+                                      // Gap, used to be V4HandleType
+            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);
+    };
+
+    inline bool operator==(const QQmlPropertyData &) const;
+
+    Flags flags() const { return m_flags; }
+    void setFlags(Flags f)
+    {
+        unsigned otherBits = m_flags.otherBits;
+        m_flags = f;
+        m_flags.otherBits = otherBits;
+    }
+
+    bool isValid() const { return coreIndex() != -1; }
+
+    bool isConstant() const { return m_flags.isConstant; }
+    bool isWritable() const { return m_flags.isWritable; }
+    void setWritable(bool onoff) { m_flags.isWritable = onoff; }
+    bool isResettable() const { return m_flags.isResettable; }
+    bool isAlias() const { return m_flags.isAlias; }
+    bool isFinal() const { return m_flags.isFinal; }
+    bool isOverridden() const { return m_flags.isOverridden; }
+    bool isDirect() const { return m_flags.isDirect; }
+    bool hasStaticMetaCallFunction() const { return staticMetaCallFunction() != nullptr; }
+    bool isFunction() const { return m_flags.type == Flags::FunctionType; }
+    bool isQObject() const { return m_flags.type == Flags::QObjectDerivedType; }
+    bool isEnum() const { return m_flags.type == Flags::EnumType; }
+    bool isQList() const { return m_flags.type == Flags::QListType; }
+    bool isQmlBinding() const { return m_flags.type == Flags::QmlBindingType; }
+    bool isQJSValue() const { return m_flags.type == Flags::QJSValueType; }
+    bool isVarProperty() const { return m_flags.type == Flags::VarPropertyType; }
+    bool isQVariant() const { return m_flags.type == Flags::QVariantType; }
+    bool isVMEFunction() const { return m_flags.isVMEFunction; }
+    bool hasArguments() const { return m_flags.hasArguments; }
+    bool isSignal() const { return m_flags.isSignal; }
+    bool isVMESignal() const { return m_flags.isVMESignal; }
+    bool isV4Function() const { return m_flags.isV4Function; }
+    bool isSignalHandler() const { return m_flags.isSignalHandler; }
+    bool isOverload() const { return m_flags.isOverload; }
+    void setOverload(bool onoff) { m_flags.isOverload = onoff; }
+    bool isCloned() const { return m_flags.isCloned; }
+    bool isConstructor() const { return m_flags.isConstructor; }
+
+    bool hasOverride() const { return overrideIndex() >= 0; }
+    bool hasRevision() const { return revision() != 0; }
+
+    bool isFullyResolved() const { return !m_flags.notFullyResolved; }
+
+    int propType() const { Q_ASSERT(isFullyResolved()); return m_propType; }
+    void setPropType(int pt)
+    {
+        Q_ASSERT(pt >= 0);
+        Q_ASSERT(pt <= std::numeric_limits<qint16>::max());
+        m_propType = quint16(pt);
+    }
+
+    int notifyIndex() const { return m_notifyIndex; }
+    void setNotifyIndex(int idx)
+    {
+        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
+        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
+        m_notifyIndex = qint16(idx);
+    }
+
+    bool overrideIndexIsProperty() const { return m_flags.overrideIndexIsProperty; }
+    void setOverrideIndexIsProperty(bool onoff) { m_flags.overrideIndexIsProperty = onoff; }
+
+    int overrideIndex() const { return m_overrideIndex; }
+    void setOverrideIndex(int idx)
+    {
+        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
+        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
+        m_overrideIndex = qint16(idx);
+    }
+
+    int coreIndex() const { return m_coreIndex; }
+    void setCoreIndex(int idx)
+    {
+        Q_ASSERT(idx >= std::numeric_limits<qint16>::min());
+        Q_ASSERT(idx <= std::numeric_limits<qint16>::max());
+        m_coreIndex = qint16(idx);
+    }
+
+    quint8 revision() const { return m_revision; }
+    void setRevision(quint8 rev)
+    {
+        Q_ASSERT(rev <= std::numeric_limits<quint8>::max());
+        m_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 m_typeMinorVersion; }
+    void setTypeMinorVersion(quint8 rev)
+    {
+        Q_ASSERT(rev <= std::numeric_limits<quint8>::max());
+        m_typeMinorVersion = quint8(rev);
+    }
+
+    QQmlPropertyCacheMethodArguments *arguments() const { return m_arguments; }
+    void setArguments(QQmlPropertyCacheMethodArguments *args) { m_arguments = args; }
+
+    int metaObjectOffset() const { return m_metaObjectOffset; }
+    void setMetaObjectOffset(int off)
+    {
+        Q_ASSERT(off >= std::numeric_limits<qint16>::min());
+        Q_ASSERT(off <= std::numeric_limits<qint16>::max());
+        m_metaObjectOffset = qint16(off);
+    }
+
+    StaticMetaCallFunction staticMetaCallFunction() const { return m_staticMetaCallFunction; }
+    void trySetStaticMetaCallFunction(StaticMetaCallFunction f, unsigned relativePropertyIndex)
+    {
+        if (relativePropertyIndex < (1 << Flags::BitsLeftInFlags) - 1) {
+            m_flags.otherBits = relativePropertyIndex;
+            m_staticMetaCallFunction = f;
+        }
+    }
+    quint16 relativePropertyIndex() const { Q_ASSERT(hasStaticMetaCallFunction()); return m_flags.otherBits; }
 
     static Flags flagsForProperty(const QMetaProperty &);
     void load(const QMetaProperty &);
@@ -128,27 +312,32 @@ private:
     friend class QQmlPropertyCache;
     void lazyLoad(const QMetaProperty &);
     void lazyLoad(const QMetaMethod &);
-    bool notFullyResolved() const { return _flags.notFullyResolved; }
-};
+    bool notFullyResolved() const { return m_flags.notFullyResolved; }
 
-QQmlPropertyData::QQmlPropertyData()
-{
-    setCoreIndex(-1);
-    setPropType(0);
-    setNotifyIndex(-1);
-    setOverrideIndex(-1);
-    setRevision(0);
-    setMetaObjectOffset(-1);
-    setArguments(nullptr);
-    trySetStaticMetaCallFunction(nullptr, 0);
-}
+    Flags m_flags;
+    qint16 m_coreIndex = -1;
+    quint16 m_propType = 0;
 
-QQmlPropertyData::QQmlPropertyData(const QQmlPropertyRawData &d)
-{
-    *(static_cast<QQmlPropertyRawData *>(this)) = d;
-}
+    // The notify index is in the range returned by QObjectPrivate::signalIndex().
+    // This is different from QMetaMethod::methodIndex().
+    qint16 m_notifyIndex = -1;
+    qint16 m_overrideIndex = -1;
 
-bool QQmlPropertyData::operator==(const QQmlPropertyRawData &other)
+    quint8 m_revision = 0;
+    quint8 m_typeMinorVersion = 0;
+    qint16 m_metaObjectOffset = -1;
+
+    QQmlPropertyCacheMethodArguments *m_arguments = nullptr;
+    StaticMetaCallFunction m_staticMetaCallFunction = nullptr;
+};
+
+#if QT_POINTER_SIZE == 4
+    Q_STATIC_ASSERT(sizeof(QQmlPropertyData) == 24);
+#else // QT_POINTER_SIZE == 8
+    Q_STATIC_ASSERT(sizeof(QQmlPropertyData) == 32);
+#endif
+
+bool QQmlPropertyData::operator==(const QQmlPropertyData &other) const
 {
     return flags() == other.flags() &&
             propType() == other.propType() &&
@@ -157,6 +346,64 @@ bool QQmlPropertyData::operator==(const QQmlPropertyRawData &other)
             revision() == other.revision();
 }
 
+QQmlPropertyData::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 QQmlPropertyData::Flags::operator==(const QQmlPropertyData::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 QQmlPropertyData::Flags::copyPropertyTypeFlags(QQmlPropertyData::Flags from)
+{
+    switch (from.type) {
+    case QObjectDerivedType:
+    case EnumType:
+    case QListType:
+    case QmlBindingType:
+    case QJSValueType:
+    case QVariantType:
+        type = from.type;
+    }
+}
+
 Q_DECLARE_OPERATORS_FOR_FLAGS(QQmlPropertyData::WriteFlags)
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/qqmlpropertyrawdata_p.h b/src/qml/qml/qqmlpropertyrawdata_p.h
deleted file mode 100644
index 31d67b0953..0000000000
--- a/src/qml/qml/qqmlpropertyrawdata_p.h
+++ /dev/null
@@ -1,339 +0,0 @@
-/****************************************************************************
-**
-** 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
-                                      // Gap, used to be V4HandleType
-            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 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 QVariantType:
-        type = from.type;
-    }
-}
-
-QT_END_NAMESPACE
-
-#endif // QQMLPROPERTYRAWDATA_P_H