QML: Make all fields in QQmlPropertyRawData private

And add accessors. This makes it easier later on to change the storage
of the fields.

Change-Id: I21163668ac83a7d52f398981baf3c27ef161c177
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

1 files changed, 107 insertions, 108 deletions

diff --git a/src/qml/qml/qqmlpropertycache.cpp b/src/qml/qml/qqmlpropertycache.cpp
index 38fddc8253..af9b8cc045 100644
--- a/src/qml/qml/qqmlpropertycache.cpp
+++ b/src/qml/qml/qqmlpropertycache.cpp
@@ -145,102 +145,102 @@ QQmlPropertyData::flagsForProperty(const QMetaProperty &p, QQmlEngine *engine)
 
 void QQmlPropertyData::lazyLoad(const QMetaProperty &p)
 {
-    coreIndex = p.propertyIndex();
-    notifyIndex = QMetaObjectPrivate::signalIndex(p.notifySignal());
+    setCoreIndex(p.propertyIndex());
+    setNotifyIndex(QMetaObjectPrivate::signalIndex(p.notifySignal()));
     Q_ASSERT(p.revision() <= Q_INT16_MAX);
-    revision = p.revision();
+    setRevision(p.revision());
 
-    flags = fastFlagsForProperty(p);
+    _flags = fastFlagsForProperty(p);
 
     int type = static_cast<int>(p.type());
     if (type == QMetaType::QObjectStar) {
-        propType = type;
-        flags.type = Flags::QObjectDerivedType;
+        setPropType(type);
+        _flags.type = Flags::QObjectDerivedType;
     } else if (type == QMetaType::QVariant) {
-        propType = type;
-        flags.type = Flags::QVariantType;
+        setPropType(type);
+        _flags.type = Flags::QVariantType;
     } else if (type == QVariant::UserType || type == -1) {
-        propTypeName = p.typeName();
-        flags.notFullyResolved = true;
+        _flags.notFullyResolved = true;
+        setPropTypeName(p.typeName());
     } else {
-        propType = type;
+        setPropType(type);
     }
 }
 
 void QQmlPropertyData::load(const QMetaProperty &p, QQmlEngine *engine)
 {
-    propType = p.userType();
-    coreIndex = p.propertyIndex();
-    notifyIndex = QMetaObjectPrivate::signalIndex(p.notifySignal());
-    flags = fastFlagsForProperty(p);
-    flagsForPropertyType(propType, engine, flags);
+    setPropType(p.userType());
+    setCoreIndex(p.propertyIndex());
+    setNotifyIndex(QMetaObjectPrivate::signalIndex(p.notifySignal()));
+    _flags = fastFlagsForProperty(p);
+    flagsForPropertyType(propType(), engine, _flags);
     Q_ASSERT(p.revision() <= Q_INT16_MAX);
-    revision = p.revision();
+    setRevision(p.revision());
 }
 
 void QQmlPropertyData::load(const QMetaMethod &m)
 {
-    coreIndex = m.methodIndex();
-    arguments = 0;
+    setCoreIndex(m.methodIndex());
+    setArguments(nullptr);
 
-    propType = m.returnType();
+    setPropType(m.returnType());
 
-    flags.type = Flags::FunctionType;
+    _flags.type = Flags::FunctionType;
     if (m.methodType() == QMetaMethod::Signal)
-        flags.isSignal = true;
+        _flags.isSignal = true;
     else if (m.methodType() == QMetaMethod::Constructor) {
-        flags.isConstructor = true;
-        propType = QMetaType::QObjectStar;
+        _flags.isConstructor = true;
+        setPropType(QMetaType::QObjectStar);
     }
 
     if (m.parameterCount()) {
-        flags.hasArguments = true;
-        if ((m.parameterCount() == 1) && (m.parameterTypes().constFirst() == "QQmlV4Function*")) {
-            flags.isV4Function = true;
+        _flags.hasArguments = true;
+        if ((m.parameterCount() == 1) && (m.parameterTypes().first() == "QQmlV4Function*")) {
+            _flags.isV4Function = true;
         }
     }
 
     if (m.attributes() & QMetaMethod::Cloned)
-        flags.isCloned = true;
+        _flags.isCloned = true;
 
     Q_ASSERT(m.revision() <= Q_INT16_MAX);
-    revision = m.revision();
+    setRevision(m.revision());
 }
 
 void QQmlPropertyData::lazyLoad(const QMetaMethod &m)
 {
-    coreIndex = m.methodIndex();
-    propType = QMetaType::Void;
-    arguments = 0;
-    flags.type = Flags::FunctionType;
+    setCoreIndex(m.methodIndex());
+    setPropType(QMetaType::Void);
+    setArguments(nullptr);
+    _flags.type = Flags::FunctionType;
     if (m.methodType() == QMetaMethod::Signal)
-        flags.isSignal = true;
+        _flags.isSignal = true;
     else if (m.methodType() == QMetaMethod::Constructor) {
-        flags.isConstructor = true;
-        propType = QMetaType::QObjectStar;
+        _flags.isConstructor = true;
+        setPropType(QMetaType::QObjectStar);
     }
 
     const char *returnType = m.typeName();
     if (!returnType)
         returnType = "\0";
     if ((*returnType != 'v') || (qstrcmp(returnType+1, "oid") != 0)) {
-        propTypeName = returnType;
-        flags.notFullyResolved = true;
+        setPropTypeName(returnType);
+        _flags.notFullyResolved = true;
     }
 
     const int paramCount = m.parameterCount();
     if (paramCount) {
-        flags.hasArguments = true;
-        if ((paramCount == 1) && (m.parameterTypes().constFirst() == "QQmlV4Function*")) {
-            flags.isV4Function = true;
+        _flags.hasArguments = true;
+        if ((paramCount == 1) && (m.parameterTypes().first() == "QQmlV4Function*")) {
+            _flags.isV4Function = true;
         }
     }
 
     if (m.attributes() & QMetaMethod::Cloned)
-        flags.isCloned = true;
+        _flags.isCloned = true;
 
     Q_ASSERT(m.revision() <= Q_INT16_MAX);
-    revision = m.revision();
+    setRevision(m.revision());
 }
 
 /*!
@@ -343,10 +343,10 @@ void QQmlPropertyCache::appendProperty(const QString &name, QQmlPropertyData::Fl
                                        int coreIndex, int propType, int notifyIndex)
 {
     QQmlPropertyData data;
-    data.propType = propType;
-    data.coreIndex = coreIndex;
-    data.notifyIndex = notifyIndex;
-    data.flags = flags;
+    data.setPropType(propType);
+    data.setCoreIndex(coreIndex);
+    data.setNotifyIndex(notifyIndex);
+    data._flags = flags;
 
     QQmlPropertyData *old = findNamedProperty(name);
     if (old)
@@ -363,20 +363,20 @@ void QQmlPropertyCache::appendSignal(const QString &name, QQmlPropertyData::Flag
                                      const QList<QByteArray> &names)
 {
     QQmlPropertyData data;
-    data.propType = QVariant::Invalid;
-    data.coreIndex = coreIndex;
-    data.flags = flags;
-    data.arguments = 0;
+    data.setPropType(QVariant::Invalid);
+    data.setCoreIndex(coreIndex);
+    data._flags = flags;
+    data.setArguments(nullptr);
 
     QQmlPropertyData handler = data;
-    handler.flags.isSignalHandler = true;
+    handler._flags.isSignalHandler = true;
 
     if (types) {
         int argumentCount = *types;
         QQmlPropertyCacheMethodArguments *args = createArgumentsObject(argumentCount, names);
         ::memcpy(args->arguments, types, (argumentCount + 1) * sizeof(int));
         args->argumentsValid = true;
-        data.arguments = args;
+        data.setArguments(args);
     }
 
     QQmlPropertyData *old = findNamedProperty(name);
@@ -402,16 +402,16 @@ void QQmlPropertyCache::appendMethod(const QString &name, QQmlPropertyData::Flag
     int argumentCount = names.count();
 
     QQmlPropertyData data;
-    data.propType = QMetaType::QVariant;
-    data.coreIndex = coreIndex;
+    data.setPropType(QMetaType::QVariant);
+    data.setCoreIndex(coreIndex);
 
     QQmlPropertyCacheMethodArguments *args = createArgumentsObject(argumentCount, names);
     for (int ii = 0; ii < argumentCount; ++ii)
         args->arguments[ii + 1] = QMetaType::QVariant;
     args->argumentsValid = true;
-    data.arguments = args;
+    data.setArguments(args);
 
-    data.flags = flags;
+    data._flags = flags;
 
     QQmlPropertyData *old = findNamedProperty(name);
     if (old)
@@ -570,20 +570,20 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
         QQmlPropertyData *sigdata = 0;
 
         if (m.methodType() == QMetaMethod::Signal)
-            data->flags = signalFlags;
+            data->_flags = signalFlags;
         else
-            data->flags = methodFlags;
+            data->_flags = methodFlags;
 
         data->lazyLoad(m);
-        data->flags.isDirect = !dynamicMetaObject;
+        data->_flags.isDirect = !dynamicMetaObject;
 
         Q_ASSERT((allowedRevisionCache.count() - 1) < Q_INT16_MAX);
-        data->metaObjectOffset = allowedRevisionCache.count() - 1;
+        data->setMetaObjectOffset(allowedRevisionCache.count() - 1);
 
         if (data->isSignal()) {
             sigdata = &signalHandlerIndexCache[signalHandlerIndex - signalHandlerIndexCacheStart];
             *sigdata = *data;
-            sigdata->flags.isSignalHandler = true;
+            sigdata->_flags.isSignalHandler = true;
         }
 
         QQmlPropertyData *old = 0;
@@ -624,8 +624,8 @@ 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;
+            if (old->isFunction() && old->coreIndex() >= methodOffset)
+                data->_flags.isOverload = true;
 
             data->markAsOverrideOf(old);
         }
@@ -652,13 +652,13 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
 
         QQmlPropertyData *data = &propertyIndexCache[ii - propertyIndexCacheStart];
 
-        data->flags = propertyFlags;
+        data->_flags = propertyFlags;
         data->lazyLoad(p);
 
-        data->flags.isDirect = !dynamicMetaObject;
+        data->_flags.isDirect = !dynamicMetaObject;
 
         Q_ASSERT((allowedRevisionCache.count() - 1) < Q_INT16_MAX);
-        data->metaObjectOffset = allowedRevisionCache.count() - 1;
+        data->setMetaObjectOffset(allowedRevisionCache.count() - 1);
 
         QQmlPropertyData *old = 0;
 
@@ -677,11 +677,11 @@ void QQmlPropertyCache::append(const QMetaObject *metaObject,
         QQmlAccessorProperties::Property *accessorProperty = accessorProperties.property(str);
 
         // Fast properties may not be overrides or revisioned
-        Q_ASSERT(accessorProperty == 0 || (old == 0 && data->revision == 0));
+        Q_ASSERT(accessorProperty == 0 || (old == 0 && data->revision() == 0));
 
         if (accessorProperty) {
-            data->flags.hasAccessors = true;
-            data->accessors = accessorProperty->accessors;
+            data->_flags.hasAccessors = true;
+            data->setAccessors(accessorProperty->accessors);
         } else if (old) {
             data->markAsOverrideOf(old);
         }
@@ -692,10 +692,11 @@ void QQmlPropertyCache::resolve(QQmlPropertyData *data) const
 {
     Q_ASSERT(data->notFullyResolved());
 
-    data->propType = QMetaType::type(data->propTypeName);
+    data->setPropType(QMetaType::type(data->propTypeName()));
+    data->_flags.notFullyResolved = false;
 
     if (!data->isFunction()) {
-        if (data->propType == QMetaType::UnknownType) {
+        if (data->propType() == QMetaType::UnknownType) {
             const QMetaObject *mo = _metaObject;
             QQmlPropertyCache *p = _parent;
             while (p && (!mo || _ownMetaObject)) {
@@ -704,22 +705,20 @@ void QQmlPropertyCache::resolve(QQmlPropertyData *data) const
             }
 
             int propOffset = mo->propertyOffset();
-            if (mo && data->coreIndex < propOffset + mo->propertyCount()) {
-                while (data->coreIndex < propOffset) {
+            if (mo && data->coreIndex() < propOffset + mo->propertyCount()) {
+                while (data->coreIndex() < propOffset) {
                     mo = mo->superClass();
                     propOffset = mo->propertyOffset();
                 }
 
                 int registerResult = -1;
                 void *argv[] = { &registerResult };
-                mo->static_metacall(QMetaObject::RegisterPropertyMetaType, data->coreIndex - propOffset, argv);
-                data->propType = registerResult == -1 ? QMetaType::UnknownType : registerResult;
+                mo->static_metacall(QMetaObject::RegisterPropertyMetaType, data->coreIndex() - propOffset, argv);
+                data->setPropType(registerResult == -1 ? QMetaType::UnknownType : registerResult);
             }
         }
-        flagsForPropertyType(data->propType, engine->qmlEngine(), data->flags);
+        flagsForPropertyType(data->propType(), engine->qmlEngine(), data->_flags);
     }
-
-    data->flags.notFullyResolved = false;
 }
 
 void QQmlPropertyCache::updateRecur(const QMetaObject *metaObject)
@@ -873,25 +872,25 @@ QString QQmlPropertyData::name(QObject *object) const
 
 QString QQmlPropertyData::name(const QMetaObject *metaObject) const
 {
-    if (!metaObject || coreIndex == -1)
+    if (!metaObject || coreIndex() == -1)
         return QString();
 
     if (isFunction()) {
-        QMetaMethod m = metaObject->method(coreIndex);
+        QMetaMethod m = metaObject->method(coreIndex());
 
         return QString::fromUtf8(m.name().constData());
     } else {
-        QMetaProperty p = metaObject->property(coreIndex);
+        QMetaProperty p = metaObject->property(coreIndex());
         return QString::fromUtf8(p.name());
     }
 }
 
 void QQmlPropertyData::markAsOverrideOf(QQmlPropertyData *predecessor)
 {
-    overrideIndexIsProperty = !predecessor->isFunction();
-    overrideIndex = predecessor->coreIndex;
+    setOverrideIndexIsProperty(!predecessor->isFunction());
+    setOverrideIndex(predecessor->coreIndex());
 
-    predecessor->flags.isOverridden = true;
+    predecessor->_flags.isOverridden = true;
 }
 
 struct StaticQtMetaObject : public QObject
@@ -1124,7 +1123,7 @@ void QQmlPropertyCache::toMetaObjectBuilder(QMetaObjectBuilder &builder)
 {
     struct Sort { static bool lt(const QPair<QString, QQmlPropertyData *> &lhs,
                                  const QPair<QString, QQmlPropertyData *> &rhs) {
-        return lhs.second->coreIndex < rhs.second->coreIndex;
+        return lhs.second->coreIndex() < rhs.second->coreIndex();
     } };
 
     struct Insert { static void in(QQmlPropertyCache *This,
@@ -1135,7 +1134,7 @@ void QQmlPropertyCache::toMetaObjectBuilder(QMetaObjectBuilder &builder)
             return;
 
         if (data->isFunction()) {
-            if (data->coreIndex < This->methodIndexCacheStart)
+            if (data->coreIndex() < This->methodIndexCacheStart)
                 return;
 
             QPair<QString, QQmlPropertyData *> entry = qMakePair((QString)iter.key(), data);
@@ -1145,7 +1144,7 @@ void QQmlPropertyCache::toMetaObjectBuilder(QMetaObjectBuilder &builder)
             data = This->overrideData(data);
             if (data && !data->isFunction()) Insert::in(This, properties, methods, iter, data);
         } else {
-            if (data->coreIndex < This->propertyIndexCacheStart)
+            if (data->coreIndex() < This->propertyIndexCacheStart)
                 return;
 
             QPair<QString, QQmlPropertyData *> entry = qMakePair((QString)iter.key(), data);
@@ -1176,11 +1175,11 @@ void QQmlPropertyCache::toMetaObjectBuilder(QMetaObjectBuilder &builder)
         QQmlPropertyData *data = properties.at(ii).second;
 
         int notifierId = -1;
-        if (data->notifyIndex != -1)
-            notifierId = data->notifyIndex - signalHandlerIndexCacheStart;
+        if (data->notifyIndex() != -1)
+            notifierId = data->notifyIndex() - signalHandlerIndexCacheStart;
 
         QMetaPropertyBuilder property = builder.addProperty(properties.at(ii).first.toUtf8(),
-                                                            QMetaType::typeName(data->propType),
+                                                            QMetaType::typeName(data->propType()),
                                                             notifierId);
 
         property.setReadable(true);
@@ -1192,8 +1191,8 @@ void QQmlPropertyCache::toMetaObjectBuilder(QMetaObjectBuilder &builder)
         QQmlPropertyData *data = methods.at(ii).second;
 
         QByteArray returnType;
-        if (data->propType != 0)
-            returnType = QMetaType::typeName(data->propType);
+        if (data->propType() != 0)
+            returnType = QMetaType::typeName(data->propType());
 
         QByteArray signature;
         // '+=' reserves extra capacity. Follow-up appending will be probably free.
@@ -1201,7 +1200,7 @@ void QQmlPropertyCache::toMetaObjectBuilder(QMetaObjectBuilder &builder)
 
         QQmlPropertyCacheMethodArguments *arguments = 0;
         if (data->hasArguments()) {
-            arguments = (QQmlPropertyCacheMethodArguments *)data->arguments;
+            arguments = (QQmlPropertyCacheMethodArguments *)data->arguments();
             Q_ASSERT(arguments->argumentsValid);
             for (int ii = 0; ii < arguments->arguments[0]; ++ii) {
                 if (ii != 0) signature.append(',');
@@ -1228,7 +1227,7 @@ void QQmlPropertyCache::toMetaObjectBuilder(QMetaObjectBuilder &builder)
 
     if (!_defaultPropertyName.isEmpty()) {
         QQmlPropertyData *dp = property(_defaultPropertyName, 0, 0);
-        if (dp && dp->coreIndex >= propertyIndexCacheStart) {
+        if (dp && dp->coreIndex() >= propertyIndexCacheStart) {
             Q_ASSERT(!dp->isFunction());
             builder.addClassInfo("DefaultProperty", _defaultPropertyName.toUtf8());
         }
@@ -1452,7 +1451,7 @@ QList<QByteArray> QQmlPropertyCache::signalParameterNames(int index) const
 {
     QQmlPropertyData *signalData = signal(index);
     if (signalData && signalData->hasArguments()) {
-        QQmlPropertyCacheMethodArguments *args = (QQmlPropertyCacheMethodArguments *)signalData->arguments;
+        QQmlPropertyCacheMethodArguments *args = (QQmlPropertyCacheMethodArguments *)signalData->arguments();
         if (args && args->names)
             return *args->names;
         const QMetaMethod &method = QMetaObjectPrivate::signal(firstCppMetaObject(), index);
@@ -1554,9 +1553,9 @@ QQmlPropertyCache *QQmlMetaObject::propertyCache(QQmlEnginePrivate *e) const
 
 int QQmlMetaObject::methodReturnType(const QQmlPropertyData &data, QByteArray *unknownTypeError) const
 {
-    Q_ASSERT(!_m.isNull() && data.coreIndex >= 0);
+    Q_ASSERT(!_m.isNull() && data.coreIndex() >= 0);
 
-    int type = data.propType;
+    int type = data.propType();
 
     const char *propTypeName = 0;
 
@@ -1566,16 +1565,16 @@ int QQmlMetaObject::methodReturnType(const QQmlPropertyData &data, QByteArray *u
 
         if (_m.isT1()) {
             QQmlPropertyCache *c = _m.asT1();
-            Q_ASSERT(data.coreIndex < c->methodIndexCacheStart + c->methodIndexCache.count());
+            Q_ASSERT(data.coreIndex() < c->methodIndexCacheStart + c->methodIndexCache.count());
 
-            while (data.coreIndex < c->methodIndexCacheStart)
+            while (data.coreIndex() < c->methodIndexCacheStart)
                 c = c->_parent;
 
             const QMetaObject *metaObject = c->createMetaObject();
             Q_ASSERT(metaObject);
-            m = metaObject->method(data.coreIndex);
+            m = metaObject->method(data.coreIndex());
         } else {
-            m = _m.asT2()->method(data.coreIndex);
+            m = _m.asT2()->method(data.coreIndex());
         }
 
         type = m.returnType();
@@ -1615,19 +1614,19 @@ int *QQmlMetaObject::methodParameterTypes(int index, ArgTypeStorage *argStorage,
 
         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;
+        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) {
+        if (!rv->arguments()) {
             A *args = c->createArgumentsObject(argc, m.parameterNames());
-            rv->arguments = args;
+            rv->setArguments(args);
         }
-        A *args = static_cast<A *>(rv->arguments);
+        A *args = static_cast<A *>(rv->arguments());
 
         QList<QByteArray> argTypeNames; // Only loaded if needed
 
@@ -1651,7 +1650,7 @@ int *QQmlMetaObject::methodParameterTypes(int index, ArgTypeStorage *argStorage,
             args->arguments[ii + 1] = type;
         }
         args->argumentsValid = true;
-        return static_cast<A *>(rv->arguments)->arguments;
+        return static_cast<A *>(rv->arguments())->arguments;
 
     } else {
         QMetaMethod m = _m.asT2()->method(index);