5 files changed, 128 insertions, 149 deletions
diff --git a/sources/pyside6/libpyside/pysideproperty.cpp b/sources/pyside6/libpyside/pysideproperty.cpp
index d6dda6708..720050335 100644
--- a/sources/pyside6/libpyside/pysideproperty.cpp
+++ b/sources/pyside6/libpyside/pysideproperty.cpp
@@ -121,46 +121,82 @@ PyTypeObject *PySideProperty_TypeF(void)
     return type;
 }
 
-static void qpropertyMetaCall(PySideProperty *pp, PyObject *self, QMetaObject::Call call, void **args)
-{
-    Shiboken::Conversions::SpecificConverter converter(pp->d->typeName);
-    Q_ASSERT(converter);
-
-    switch(call) {
-        case QMetaObject::ReadProperty:
-        {
-            PyObject *value = PySide::Property::getValue(pp, self);
-            if (value) {
-                converter.toCpp(value, args[0]);
-                Py_DECREF(value);
-            }
-            break;
-        }
+PySidePropertyPrivate::~PySidePropertyPrivate() = default;
 
-        case QMetaObject::WriteProperty:
-        {
-            Shiboken::AutoDecRef value(converter.toPython(args[0]));
-            PySide::Property::setValue(pp, self, value);
-            break;
-        }
+PyObject *PySidePropertyPrivate::getValue(PyObject *source)
+{
+    if (fget) {
+        Shiboken::AutoDecRef args(PyTuple_New(1));
+        Py_INCREF(source);
+        PyTuple_SET_ITEM(args, 0, source);
+        return  PyObject_CallObject(fget, args);
+    }
+    return nullptr;
+}
 
-        case QMetaObject::ResetProperty:
-        {
-            PySide::Property::reset(pp, self);
-            break;
-        }
+int PySidePropertyPrivate::setValue(PyObject *source, PyObject *value)
+{
+    if (fset && value) {
+        Shiboken::AutoDecRef args(PyTuple_New(2));
+        PyTuple_SET_ITEM(args, 0, source);
+        PyTuple_SET_ITEM(args, 1, value);
+        Py_INCREF(source);
+        Py_INCREF(value);
+        Shiboken::AutoDecRef result(PyObject_CallObject(fset, args));
+        return (result.isNull() ? -1 : 0);
+    }
+    if (fdel) {
+        Shiboken::AutoDecRef args(PyTuple_New(1));
+        PyTuple_SET_ITEM(args, 0, source);
+        Py_INCREF(source);
+        Shiboken::AutoDecRef result(PyObject_CallObject(fdel, args));
+        return (result.isNull() ? -1 : 0);
+    }
+    PyErr_SetString(PyExc_AttributeError, "Attribute is read only");
+    return -1;
+}
 
-        // just to avoid gcc warnings
-        case QMetaObject::BindableProperty:
-        case QMetaObject::InvokeMetaMethod:
-        case QMetaObject::CreateInstance:
-        case QMetaObject::IndexOfMethod:
-        case QMetaObject::RegisterPropertyMetaType:
-        case QMetaObject::RegisterMethodArgumentMetaType:
-            break;
+int PySidePropertyPrivate::reset(PyObject *source)
+{
+    if (freset) {
+        Shiboken::AutoDecRef args(PyTuple_New(1));
+        Py_INCREF(source);
+        PyTuple_SET_ITEM(args, 0, source);
+        Shiboken::AutoDecRef result(PyObject_CallObject(freset, args));
+        return (result.isNull() ? -1 : 0);
     }
+    return -1;
 }
 
+void PySidePropertyPrivate::metaCall(PyObject *source, QMetaObject::Call call, void **args)
+{
+    switch (call) {
+    case QMetaObject::ReadProperty: {
+        Shiboken::Conversions::SpecificConverter converter(typeName);
+        Q_ASSERT(converter);
+        if (PyObject *value = getValue(source)) {
+            converter.toCpp(value, args[0]);
+            Py_DECREF(value);
+        }
+    }
+        break;
+
+    case QMetaObject::WriteProperty: {
+        Shiboken::Conversions::SpecificConverter converter(typeName);
+        Q_ASSERT(converter);
+        Shiboken::AutoDecRef value(converter.toPython(args[0]));
+        setValue(source, value);
+    }
+        break;
+
+    case QMetaObject::ResetProperty:
+        reset(source);
+        break;
+
+    default:
+        break;
+    }
+}
 
 static PyObject *qpropertyTpNew(PyTypeObject *subtype, PyObject * /* args */, PyObject * /* kwds */)
 {
@@ -174,7 +210,6 @@ static int qpropertyTpInit(PyObject *self, PyObject *args, PyObject *kwds)
     PyObject *type = nullptr;
     auto data = reinterpret_cast<PySideProperty *>(self);
     PySidePropertyPrivate *pData = data->d;
-    pData->metaCallHandler = &qpropertyMetaCall;
 
     static const char *kwlist[] = {"type", "fget", "fset", "freset", "fdel", "doc", "notify",
                                    "designable", "scriptable", "stored",
@@ -471,53 +506,19 @@ bool checkType(PyObject *pyObj)
     return false;
 }
 
-int setValue(PySideProperty *self, PyObject *source, PyObject *value)
+PyObject *getValue(PySideProperty *self, PyObject *source)
 {
-    PyObject *fset = self->d->fset;
-    if (fset && value) {
-        Shiboken::AutoDecRef args(PyTuple_New(2));
-        PyTuple_SET_ITEM(args, 0, source);
-        PyTuple_SET_ITEM(args, 1, value);
-        Py_INCREF(source);
-        Py_INCREF(value);
-        Shiboken::AutoDecRef result(PyObject_CallObject(fset, args));
-        return (result.isNull() ? -1 : 0);
-    }
-    PyObject *fdel = self->d->fdel;
-    if (fdel) {
-        Shiboken::AutoDecRef args(PyTuple_New(1));
-        PyTuple_SET_ITEM(args, 0, source);
-        Py_INCREF(source);
-        Shiboken::AutoDecRef result(PyObject_CallObject(fdel, args));
-        return (result.isNull() ? -1 : 0);
-    }
-    PyErr_SetString(PyExc_AttributeError, "Attibute read only");
-    return -1;
+    return self->d->getValue(source);
 }
 
-PyObject *getValue(PySideProperty *self, PyObject *source)
+int setValue(PySideProperty *self, PyObject *source, PyObject *value)
 {
-    PyObject *fget = self->d->fget;
-    if (fget) {
-        Shiboken::AutoDecRef args(PyTuple_New(1));
-        Py_INCREF(source);
-        PyTuple_SET_ITEM(args, 0, source);
-        return  PyObject_CallObject(fget, args);
-    }
-    return nullptr;
+    return self->d->setValue(source, value);
 }
 
 int reset(PySideProperty *self, PyObject *source)
 {
-    PyObject *freset = self->d->freset;
-    if (freset) {
-        Shiboken::AutoDecRef args(PyTuple_New(1));
-        Py_INCREF(source);
-        PyTuple_SET_ITEM(args, 0, source);
-        Shiboken::AutoDecRef result(PyObject_CallObject(freset, args));
-        return (result.isNull() ? -1 : 0);
-    }
-    return -1;
+    return self->d->reset(source);
 }
 
 const char *getTypeName(const PySideProperty *self)
@@ -598,25 +599,10 @@ const char *getNotifyName(PySideProperty *self)
         ? nullptr : self->d->notifySignature.constData();
 }
 
-void setMetaCallHandler(PySideProperty *self, MetaCallHandler handler)
-{
-    self->d->metaCallHandler = handler;
-}
-
 void setTypeName(PySideProperty *self, const char *typeName)
 {
     self->d->typeName = typeName;
 }
 
-void setUserData(PySideProperty *self, void *data)
-{
-    self->d->userData = data;
-}
-
-void *userData(PySideProperty *self)
-{
-    return self->d->userData;
-}
-
 } //namespace Property
 } //namespace PySide
diff --git a/sources/pyside6/libpyside/pysideproperty.h b/sources/pyside6/libpyside/pysideproperty.h
index c5a48caed..489341d53 100644
--- a/sources/pyside6/libpyside/pysideproperty.h
+++ b/sources/pyside6/libpyside/pysideproperty.h
@@ -46,11 +46,12 @@
 
 #include <QtCore/QMetaObject>
 
+class PySidePropertyPrivate;
+
 extern "C"
 {
     extern PYSIDE_API PyTypeObject *PySideProperty_TypeF(void);
 
-    struct PySidePropertyPrivate;
     struct PYSIDE_API PySideProperty
     {
         PyObject_HEAD
@@ -60,8 +61,6 @@ extern "C"
 
 namespace PySide { namespace Property {
 
-typedef void (*MetaCallHandler)(PySideProperty*,PyObject*,QMetaObject::Call, void**);
-
 PYSIDE_API bool checkType(PyObject *pyObj);
 
 /**
@@ -103,13 +102,8 @@ PYSIDE_API const char *getNotifyName(PySideProperty *self);
  **/
 PYSIDE_API PySideProperty *getObject(PyObject *source, PyObject *name);
 
-PYSIDE_API void setMetaCallHandler(PySideProperty *self, MetaCallHandler handler);
-
 PYSIDE_API void setTypeName(PySideProperty *self, const char *typeName);
 
-PYSIDE_API void setUserData(PySideProperty *self, void *data);
-PYSIDE_API void* userData(PySideProperty *self);
-
 } //namespace Property
 } //namespace PySide
 
diff --git a/sources/pyside6/libpyside/pysideproperty_p.h b/sources/pyside6/libpyside/pysideproperty_p.h
index e7b6e4d77..4b6498158 100644
--- a/sources/pyside6/libpyside/pysideproperty_p.h
+++ b/sources/pyside6/libpyside/pysideproperty_p.h
@@ -44,13 +44,22 @@
 #include <QtCore/QByteArray>
 #include <QMetaObject>
 #include "pysideproperty.h"
+#include <pysidemacros.h>
 
 struct PySideProperty;
 
-struct PySidePropertyPrivate
+class PYSIDE_API PySidePropertyPrivate
 {
+public:
+    virtual ~PySidePropertyPrivate();
+
+    virtual void metaCall(PyObject *source, QMetaObject::Call call, void **args);
+
+    PyObject *getValue(PyObject *source);
+    int setValue(PyObject *source, PyObject *value);
+    int reset(PyObject *source);
+
     QByteArray typeName;
-    PySide::Property::MetaCallHandler metaCallHandler = nullptr;
     PyObject *fget = nullptr;
     PyObject *fset = nullptr;
     PyObject *freset = nullptr;
@@ -65,7 +74,6 @@ struct PySidePropertyPrivate
     bool user = false;
     bool constant = false;
     bool final = false;
-    void *userData = nullptr;
 };
 
 namespace PySide { namespace Property {
diff --git a/sources/pyside6/libpyside/signalmanager.cpp b/sources/pyside6/libpyside/signalmanager.cpp
index 1b5a0dee7..5fb9b85c1 100644
--- a/sources/pyside6/libpyside/signalmanager.cpp
+++ b/sources/pyside6/libpyside/signalmanager.cpp
@@ -410,7 +410,7 @@ int SignalManager::SignalManagerPrivate::qtPropertyMetacall(QObject *object,
         qWarning("Invalid property: %s.", mp.name());
         return false;
     }
-    pp->d->metaCallHandler(pp, pySelf, call, args);
+    pp->d->metaCall(pySelf, call, args);
     Py_XDECREF(pp);
 
     if (PyErr_Occurred())
diff --git a/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp b/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
index df3a0f1d0..47c33b3e2 100644
--- a/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
+++ b/sources/pyside6/libpysideqml/pysideqmllistproperty.cpp
@@ -44,35 +44,42 @@
 #include <signature.h>
 
 #include <pysideproperty.h>
+#include <pysideproperty_p.h>
 
 #include <QtCore/QObject>
 #include <QtQml/QQmlListProperty>
 
-// Forward declarations.
-static void propListMetaCall(PySideProperty *pp, PyObject *self, QMetaObject::Call call,
-                             void **args);
+// This is the user data we store in the property.
+class QmlListPropertyPrivate : public PySidePropertyPrivate
+{
+public:
+    void metaCall(PyObject *source, QMetaObject::Call call, void **args) override;
+
+    PyTypeObject *type = nullptr;
+    PyObject *append = nullptr;
+    PyObject *count = nullptr;
+    PyObject *at = nullptr;
+    PyObject *clear = nullptr;
+    PyObject *replace = nullptr;
+    PyObject *removeLast = nullptr;
+};
 
 extern "C"
 {
 
-// This is the user data we store in the property.
-struct QmlListProperty
+static PyObject *propList_tp_new(PyTypeObject *subtype, PyObject * /* args */, PyObject * /* kwds */)
 {
-    PyTypeObject *type;
-    PyObject *append;
-    PyObject *count;
-    PyObject *at;
-    PyObject *clear;
-    PyObject *replace;
-    PyObject *removeLast;
-};
+    PySideProperty *me = reinterpret_cast<PySideProperty *>(subtype->tp_alloc(subtype, 0));
+    me->d = new QmlListPropertyPrivate;
+    return reinterpret_cast<PyObject *>(me);
+}
 
 static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds)
 {
     static const char *kwlist[] = {"type", "append", "count", "at", "clear", "replace", "removeLast", 0};
     PySideProperty *pySelf = reinterpret_cast<PySideProperty *>(self);
-    QmlListProperty *data = new QmlListProperty;
-    memset(data, 0, sizeof(QmlListProperty));
+
+    auto *data = static_cast<QmlListPropertyPrivate *>(pySelf->d);
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds,
                                      "O|OOOOOO:QtQml.ListProperty", (char **) kwlist,
@@ -83,7 +90,6 @@ static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds)
                                      &data->clear,
                                      &data->replace,
                                      &data->removeLast)) {
-        delete data;
         return -1;
     }
 
@@ -92,7 +98,6 @@ static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds)
     if (!PySequence_Contains(data->type->tp_mro, reinterpret_cast<PyObject *>(qobjectType))) {
         PyErr_Format(PyExc_TypeError, "A type inherited from %s expected, got %s.",
                      qobjectType->tp_name, data->type->tp_name);
-        delete data;
         return -1;
     }
 
@@ -103,29 +108,17 @@ static int propListTpInit(PyObject *self, PyObject *args, PyObject *kwds)
         (data->replace && data->replace != Py_None && !PyCallable_Check(data->replace)) ||
         (data->removeLast && data->removeLast != Py_None && !PyCallable_Check(data->removeLast))) {
         PyErr_Format(PyExc_TypeError, "Non-callable parameter given");
-        delete data;
         return -1;
     }
 
-    PySide::Property::setMetaCallHandler(pySelf, &propListMetaCall);
-    PySide::Property::setTypeName(pySelf, "QQmlListProperty<QObject>");
-    PySide::Property::setUserData(pySelf, data);
+    data->typeName = QByteArrayLiteral("QQmlListProperty<QObject>");
 
     return 0;
 }
 
-void propListTpFree(void *self)
-{
-    auto pySelf = reinterpret_cast<PySideProperty *>(self);
-    delete reinterpret_cast<QmlListProperty *>(PySide::Property::userData(pySelf));
-    // calls base type constructor
-    Py_TYPE(pySelf)->tp_base->tp_free(self);
-}
-
 static PyType_Slot PropertyListType_slots[] = {
+    {Py_tp_new, reinterpret_cast<void *>(propList_tp_new)},
     {Py_tp_init, reinterpret_cast<void *>(propListTpInit)},
-    {Py_tp_free, reinterpret_cast<void *>(propListTpFree)},
-    {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
     {0, nullptr}
 };
 static PyType_Spec PropertyListType_spec = {
@@ -158,7 +151,7 @@ void propListAppender(QQmlListProperty<QObject> *propList, QObject *item)
     PyTuple_SET_ITEM(args, 1,
                      Shiboken::Conversions::pointerToPython(qobjectType, item));
 
-    auto data = reinterpret_cast<QmlListProperty *>(propList->data);
+    auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
     Shiboken::AutoDecRef retVal(PyObject_CallObject(data->append, args));
 
     if (PyErr_Occurred())
@@ -174,7 +167,7 @@ qsizetype propListCount(QQmlListProperty<QObject> *propList)
     PyTuple_SET_ITEM(args, 0,
                      Shiboken::Conversions::pointerToPython(qObjectType(), propList->object));
 
-    auto data = reinterpret_cast<QmlListProperty *>(propList->data);
+    auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
     Shiboken::AutoDecRef retVal(PyObject_CallObject(data->count, args));
 
     // Check return type
@@ -203,7 +196,7 @@ QObject *propListAt(QQmlListProperty<QObject> *propList, qsizetype index)
     PyTuple_SET_ITEM(args, 1,
                      Shiboken::Conversions::copyToPython(converter, &index));
 
-    auto data = reinterpret_cast<QmlListProperty *>(propList->data);
+    auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
     Shiboken::AutoDecRef retVal(PyObject_CallObject(data->at, args));
 
     QObject *result = 0;
@@ -224,7 +217,7 @@ void propListClear(QQmlListProperty<QObject> * propList)
     PyTuple_SET_ITEM(args, 0,
                      Shiboken::Conversions::pointerToPython(qobjectType, propList->object));
 
-    auto data = reinterpret_cast<QmlListProperty *>(propList->data);
+    auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
     Shiboken::AutoDecRef retVal(PyObject_CallObject(data->clear, args));
 
     if (PyErr_Occurred())
@@ -246,7 +239,7 @@ void propListReplace(QQmlListProperty<QObject> *propList, qsizetype index, QObje
     PyTuple_SET_ITEM(args, 2,
                      Shiboken::Conversions::pointerToPython(qobjectType, value));
 
-    auto data = reinterpret_cast<QmlListProperty *>(propList->data);
+    auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
     Shiboken::AutoDecRef retVal(PyObject_CallObject(data->replace, args));
 
     if (PyErr_Occurred())
@@ -263,7 +256,7 @@ void propListRemoveLast(QQmlListProperty<QObject> *propList)
     PyTuple_SET_ITEM(args, 0,
                      Shiboken::Conversions::pointerToPython(qobjectType, propList->object));
 
-    auto data = reinterpret_cast<QmlListProperty *>(propList->data);
+    auto *data = reinterpret_cast<QmlListPropertyPrivate *>(propList->data);
     Shiboken::AutoDecRef retVal(PyObject_CallObject(data->removeLast, args));
 
     if (PyErr_Occurred())
@@ -271,24 +264,22 @@ void propListRemoveLast(QQmlListProperty<QObject> *propList)
 }
 
 // qt_metacall specialization for ListProperties
-static void propListMetaCall(PySideProperty *pp, PyObject *self,
-                             QMetaObject::Call call, void **args)
+void QmlListPropertyPrivate::metaCall(PyObject *source, QMetaObject::Call call, void **args)
 {
     if (call != QMetaObject::ReadProperty)
         return;
 
-    auto data = reinterpret_cast<QmlListProperty *>(PySide::Property::userData(pp));
     QObject *qobj;
     PyTypeObject *qobjectType = qObjectType();
-    Shiboken::Conversions::pythonToCppPointer(qobjectType, self, &qobj);
+    Shiboken::Conversions::pythonToCppPointer(qobjectType, source, &qobj);
     QQmlListProperty<QObject> declProp(
-        qobj, data,
-        data->append && data->append != Py_None ? &propListAppender : nullptr,
-        data->count && data->count != Py_None ? &propListCount : nullptr,
-        data->at && data->at != Py_None ? &propListAt : nullptr,
-        data->clear && data->clear != Py_None ? &propListClear : nullptr,
-        data->replace && data->replace != Py_None ? &propListReplace : nullptr,
-        data->removeLast && data->removeLast != Py_None ? &propListRemoveLast : nullptr);
+        qobj, this,
+        append && append != Py_None ? &propListAppender : nullptr,
+        count && count != Py_None ? &propListCount : nullptr,
+        at && at != Py_None ? &propListAt : nullptr,
+        clear && clear != Py_None ? &propListClear : nullptr,
+        replace && replace != Py_None ? &propListReplace : nullptr,
+        removeLast && removeLast != Py_None ? &propListRemoveLast : nullptr);
 
     // Copy the data to the memory location requested by the meta call
     void *v = args[0];