7 files changed, 339 insertions, 28 deletions

diff --git a/sources/pyside6/libpyside/CMakeLists.txt b/sources/pyside6/libpyside/CMakeLists.txt
index 539f1f329..15ab47494 100644
--- a/sources/pyside6/libpyside/CMakeLists.txt
+++ b/sources/pyside6/libpyside/CMakeLists.txt
@@ -40,6 +40,7 @@ set(libpyside_HEADERS # installed below
     pysideslot_p.h
     pysidestaticstrings.h
     pysideutils.h
+    pysidevariantutils.h
     pysideweakref.h
     qobjectconnect.h
     signalmanager.h
@@ -59,6 +60,7 @@ set(libpyside_SRC
     pysidesignal.cpp
     pysideslot.cpp
     pysideproperty.cpp
+    pysidevariantutils.cpp
     pysideweakref.cpp
     pyside.cpp
     pyside_numpy.cpp
diff --git a/sources/pyside6/libpyside/pysidemetafunction.cpp b/sources/pyside6/libpyside/pysidemetafunction.cpp
index 48aba3c7b..7a496c4b7 100644
--- a/sources/pyside6/libpyside/pysidemetafunction.cpp
+++ b/sources/pyside6/libpyside/pysidemetafunction.cpp
@@ -4,6 +4,8 @@
 #include "pysidemetafunction.h"
 #include "pysidemetafunction_p.h"
 
+#include <signalmanager.h>
+
 #include <autodecref.h>
 #include <basewrapper.h>
 #include <sbkconverter.h>
@@ -12,6 +14,8 @@
 
 #include <QtCore/qmetaobject.h>
 
+using namespace Qt::StringLiterals;
+
 extern "C"
 {
 
@@ -164,6 +168,10 @@ bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
                 QString tmp;
                 converter.toCpp(obj, &tmp);
                 methValues[i] = tmp;
+            } else if (metaType.id() == PyObjectWrapper::metaTypeId()) {
+                // Manual conversion, see PyObjectWrapper converter registration
+                methValues[i] = QVariant::fromValue(PyObjectWrapper(obj.object()));
+                methArgs[i] = methValues[i].data();
             } else {
                 converter.toCpp(obj, methArgs[i]);
             }
diff --git a/sources/pyside6/libpyside/pysideproperty.cpp b/sources/pyside6/libpyside/pysideproperty.cpp
index e8ea2fa03..69d347043 100644
--- a/sources/pyside6/libpyside/pysideproperty.cpp
+++ b/sources/pyside6/libpyside/pysideproperty.cpp
@@ -6,6 +6,7 @@
 #include "pysideproperty_p.h"
 #include "pysidesignal.h"
 #include "pysidesignal_p.h"
+#include "signalmanager.h"
 
 #include <autodecref.h>
 #include <pep384ext.h>
@@ -17,6 +18,8 @@
 
 using namespace Shiboken;
 
+using namespace Qt::StringLiterals;
+
 extern "C"
 {
 
@@ -148,16 +151,20 @@ void PySidePropertyPrivate::metaCall(PyObject *source, QMetaObject::Call call, v
     switch (call) {
     case QMetaObject::ReadProperty: {
         AutoDecRef value(getValue(source));
-        auto *obValue = value.object();
-        if (obValue) {
-            Conversions::SpecificConverter converter(typeName);
-            if (converter) {
-                converter.toCpp(obValue, args[0]);
-            } else {
-                // PYSIDE-2160: Report an unknown type name to the caller `qtPropertyMetacall`.
-                PyErr_SetObject(PyExc_StopIteration, obValue);
-            }
+        if (value.isNull())
+            return;
+        if (typeName == "PyObject"_ba) {
+            // Manual conversion, see PyObjectWrapper converter registration
+            auto *pw = reinterpret_cast<PySide::PyObjectWrapper *>(args[0]);
+            pw->reset(value.object());
+            return;
+        }
+        if (Conversions::SpecificConverter converter(typeName); converter) {
+            converter.toCpp(value.object(), args[0]);
+            return;
         }
+        // PYSIDE-2160: Report an unknown type name to the caller `qtPropertyMetacall`.
+        PyErr_SetObject(PyExc_StopIteration, value.object());
     }
         break;
 
diff --git a/sources/pyside6/libpyside/pysidevariantutils.cpp b/sources/pyside6/libpyside/pysidevariantutils.cpp
new file mode 100644
index 000000000..729557919
--- /dev/null
+++ b/sources/pyside6/libpyside/pysidevariantutils.cpp
@@ -0,0 +1,216 @@
+// Copyright (C) 2025 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "pysidevariantutils.h"
+#include "pysideutils.h"
+
+#include <QtCore/qvariantmap.h>
+
+#include <autodecref.h>
+#include <sbkconverter.h>
+#include <basewrapper.h>
+
+using namespace Qt::StringLiterals;
+
+static const char qVariantTypeName[] = "QVariant";
+
+static void warnConverter(const char *name)
+{
+    qWarning("Type converter for: %s not registered.", name);
+}
+
+// Helper converting each item of a non-empty list using the "QVariant" converter
+static std::optional<QVariantList> pyListToVariantListHelper(PyObject *list, Py_ssize_t size)
+{
+    Q_ASSERT(size > 0);
+    QVariantList result;
+    result.reserve(size);
+    Shiboken::Conversions::SpecificConverter converter(qVariantTypeName);
+    if (!converter) {
+        warnConverter(qVariantTypeName);
+        return std::nullopt;
+    }
+    for (Py_ssize_t i = 0; i < size; ++i) {
+        Shiboken::AutoDecRef pyItem(PySequence_GetItem(list, i));
+        QVariant item;
+        converter.toCpp(pyItem.object(), &item);
+        result.append(item);
+    }
+    return result;
+}
+
+// Helper checking for a sequence of Unicode objects
+static bool isStringList(PyObject *list)
+{
+    const Py_ssize_t size = PySequence_Size(list);
+    if (size == 0)
+        return false;
+    for (Py_ssize_t i = 0; i < size; ++i) {
+        Shiboken::AutoDecRef item(PySequence_GetItem(list, i));
+        if (PyUnicode_Check(item) == 0)
+            return false;
+    }
+    return true;
+}
+
+// Helper to convert to a QStringList
+static std::optional<QStringList> listToStringList(PyObject *list)
+{
+    static const char listType[] = "QList<QString>";
+    Shiboken::Conversions::SpecificConverter converter(listType);
+    if (!converter) {
+        warnConverter(listType);
+        return std::nullopt;
+    }
+    QStringList result;
+    converter.toCpp(list, &result);
+    return result;
+}
+
+// Helper to convert a non-empty, homogenous list using the converter of the first item
+static QVariant convertToValueList(PyObject *list)
+{
+    Q_ASSERT(PySequence_Size(list) >= 0);
+
+    Shiboken::AutoDecRef element(PySequence_GetItem(list, 0));
+
+    auto *type = reinterpret_cast<PyTypeObject *>(element.object());
+    QMetaType metaType = PySide::Variant::resolveMetaType(type);
+    if (!metaType.isValid())
+        return {};
+
+    const QByteArray listTypeName = QByteArrayLiteral("QList<") + metaType.name() + '>';
+    metaType = QMetaType::fromName(listTypeName);
+    if (!metaType.isValid())
+        return {};
+
+    Shiboken::Conversions::SpecificConverter converter(listTypeName);
+    if (!converter) {
+        warnConverter(listTypeName.constData());
+        return {};
+    }
+
+    QVariant var(metaType);
+    converter.toCpp(list, &var);
+    return var;
+}
+
+namespace PySide::Variant
+{
+
+QMetaType resolveMetaType(PyTypeObject *type)
+{
+    if (!PyObject_TypeCheck(type, SbkObjectType_TypeF()))
+        return {};
+    const char *typeName = Shiboken::ObjectType::getOriginalName(type);
+    if (!typeName)
+        return {};
+    const bool valueType = '*' != typeName[qstrlen(typeName) - 1];
+    // Do not convert user type of value
+    if (valueType && Shiboken::ObjectType::isUserType(type))
+        return {};
+    QMetaType metaType = QMetaType::fromName(typeName);
+    if (metaType.isValid())
+        return metaType;
+    // Do not resolve types to value type
+    if (valueType)
+        return {};
+    // Find in base types. First check tp_bases, and only after check tp_base, because
+    // tp_base does not always point to the first base class, but rather to the first
+    // that has added any python fields or slots to its object layout.
+    // See https://mail.python.org/pipermail/python-list/2009-January/520733.html
+    if (type->tp_bases) {
+        const auto size = PyTuple_Size(type->tp_bases);
+        Py_ssize_t i = 0;
+        // PYSIDE-1887, PYSIDE-86: Skip QObject base class of QGraphicsObject;
+        // it needs to use always QGraphicsItem as a QVariant type for
+        // QGraphicsItem::itemChange() to work.
+        if (qstrcmp(typeName, "QGraphicsObject*") == 0 && size > 1) {
+            auto *firstBaseType = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(type->tp_bases, 0));
+            const char *firstBaseTypeName = Shiboken::ObjectType::getOriginalName(firstBaseType);
+            if (firstBaseTypeName != nullptr && qstrcmp(firstBaseTypeName, "QObject*") == 0)
+                ++i;
+        }
+        for ( ; i < size; ++i) {
+            auto baseType = reinterpret_cast<PyTypeObject *>(PyTuple_GetItem(type->tp_bases, i));
+            const QMetaType derived = resolveMetaType(baseType);
+            if (derived.isValid())
+                return derived;
+        }
+        return {};
+    }
+    if (type->tp_base != nullptr)
+        return resolveMetaType(type->tp_base);
+    return {};
+}
+
+std::optional<QVariantList> pyListToVariantList(PyObject *list)
+{
+    if (list == nullptr || PySequence_Check(list) == 0)
+        return std::nullopt;
+    const auto size = PySequence_Size(list);
+    if (size < 0) { // Some infinite (I/O read) thing? - bail out
+        PyErr_Clear();
+        return std::nullopt;
+    }
+    if (size == 0)
+        return QVariantList{};
+    return pyListToVariantListHelper(list, size);
+}
+
+QVariant convertToVariantList(PyObject *list)
+{
+    const auto size = PySequence_Size(list);
+    if (size < 0) { // Some infinite (I/O read) thing? - bail out
+        PyErr_Clear();
+        return {};
+    }
+    if (size == 0)
+        return QVariantList{};
+
+    if (isStringList(list)) {
+        auto stringListO = listToStringList(list);
+        if (stringListO.has_value())
+            return {stringListO.value()};
+    }
+
+    if (QVariant valueList = convertToValueList(list); valueList.isValid())
+        return valueList;
+
+    if (auto vlO = pyListToVariantListHelper(list, size); vlO.has_value())
+        return vlO.value();
+
+    return {};
+}
+
+QVariant convertToVariantMap(PyObject *map)
+{
+    if (map == nullptr || PyDict_Check(map) == 0)
+        return {};
+
+    QVariantMap result;
+    if (PyDict_Size(map) == 0)
+        return result;
+
+    Py_ssize_t pos = 0;
+    Shiboken::AutoDecRef keys(PyDict_Keys(map));
+    if (!isStringList(keys))
+        return {};
+
+    Shiboken::Conversions::SpecificConverter converter(qVariantTypeName);
+    if (!converter) {
+        warnConverter(qVariantTypeName);
+        return {};
+    }
+
+    PyObject *key{};
+    PyObject *value{};
+    while (PyDict_Next(map, &pos, &key, &value)) {
+        QVariant cppValue;
+        converter.toCpp(value, &cppValue);
+        result.insert(PySide::pyUnicodeToQString(key), cppValue);
+    }
+    return result;
+}
+
+} // namespace PySide::Variant
diff --git a/sources/pyside6/libpyside/pysidevariantutils.h b/sources/pyside6/libpyside/pysidevariantutils.h
new file mode 100644
index 000000000..b53f7ce82
--- /dev/null
+++ b/sources/pyside6/libpyside/pysidevariantutils.h
@@ -0,0 +1,37 @@
+// Copyright (C) 2025 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef PYSIDEVARIANTUTILS_H
+#define PYSIDEVARIANTUTILS_H
+
+#include <sbkpython.h>
+
+#include <pysidemacros.h>
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qvariantlist.h>
+
+#include <optional>
+
+namespace PySide::Variant
+{
+
+/// Return a QMetaType for a PyTypeObject for purposes of
+/// converting to a QVariant.
+PYSIDE_API QMetaType resolveMetaType(PyTypeObject *type);
+
+/// Convert a heterogenous Python list to a QVariantList by converting each
+/// item using the QVariant converter.
+PYSIDE_API std::optional<QVariantList> pyListToVariantList(PyObject *list);
+
+/// Converts a list to a QVariant following the PySide semantics:
+/// - A list of strings is returned as QVariant<QStringList>
+/// - A list of convertible values is returned as QVariant<QList<Value>>
+/// - Remaining types are returned as QVariant(QVariantList)
+PYSIDE_API QVariant convertToVariantList(PyObject *list);
+
+/// Converts a map to a QVariantMap (string keys and QVariant values)
+PYSIDE_API QVariant convertToVariantMap(PyObject *map);
+} // namespace PySide::Variant
+
+#endif // PYSIDEVARIANTUTILS_H
diff --git a/sources/pyside6/libpyside/signalmanager.cpp b/sources/pyside6/libpyside/signalmanager.cpp
index 933edd318..305d2f5c3 100644
--- a/sources/pyside6/libpyside/signalmanager.cpp
+++ b/sources/pyside6/libpyside/signalmanager.cpp
@@ -24,9 +24,12 @@
 #include <QtCore/qcoreevent.h>
 #include <QtCore/qdebug.h>
 #include <QtCore/qhash.h>
+#include <QtCore/qmetatype.h>
 #include <QtCore/qscopedpointer.h>
 
+#include <climits>
 #include <memory>
+#include <utility>
 
 using namespace Qt::StringLiterals;
 
@@ -36,6 +39,8 @@ using namespace Qt::StringLiterals;
 
 static PyObject *metaObjectAttr = nullptr;
 
+static int pyObjectWrapperMetaTypeId = QMetaType::UnknownType;
+
 static void destroyMetaObject(PyObject *obj)
 {
     void *ptr = PyCapsule_GetPointer(obj, nullptr);
@@ -125,6 +130,17 @@ PyObjectWrapper::PyObjectWrapper(const PyObjectWrapper &other)
     Py_XINCREF(m_me);
 }
 
+PyObjectWrapper::PyObjectWrapper(PyObjectWrapper &&other) noexcept
+ : m_me{std::exchange(other.m_me, nullptr)}
+{
+}
+
+PyObjectWrapper &PyObjectWrapper::operator=(PyObjectWrapper &&other) noexcept
+{
+    m_me = std::exchange(other.m_me, nullptr);
+    return *this;
+}
+
 PyObjectWrapper::~PyObjectWrapper()
 {
     // Check that Python is still initialized as sometimes this is called by a static destructor
@@ -156,6 +172,10 @@ PyObjectWrapper::operator PyObject *() const
     return m_me;
 }
 
+int PyObjectWrapper::metaTypeId()
+{
+    return pyObjectWrapperMetaTypeId;
+}
 
 int PyObjectWrapper::toInt() const
 {
@@ -221,7 +241,29 @@ QDataStream &operator>>(QDataStream &in, PyObjectWrapper &myObj)
     return in;
 }
 
-};
+PYSIDE_API QDebug operator<<(QDebug debug, const PyObjectWrapper &myObj)
+{
+    QDebugStateSaver saver(debug);
+    debug.noquote();
+    debug.nospace();
+    // Do not repeat the type name as it is typically called from the QVariant debug
+    // operator, which outputs the type.
+    debug << '<';
+    if (PyObject *ob = myObj) {
+        const auto refs = Py_REFCNT(ob);
+        debug << Py_TYPE(ob)->tp_name << " at " << ob;
+        if (refs == UINT_MAX) // _Py_IMMORTAL_REFCNT
+            debug << ", immortal";
+        else
+            debug << ", refs=" << refs;
+    } else {
+        debug << '0';
+    }
+    debug << '>';
+    return debug;
+}
+
+} // namespace PySide
 
 using namespace PySide;
 
@@ -238,19 +280,11 @@ struct SignalManagerPrivate
 SignalManager::QmlMetaCallErrorHandler
     SignalManagerPrivate::m_qmlMetaCallErrorHandler = nullptr;
 
-static void PyObject_PythonToCpp_PyObject_PTR(PyObject *pyIn, void *cppOut)
-{
-    *reinterpret_cast<PyObject **>(cppOut) = pyIn;
-}
-static PythonToCppFunc is_PyObject_PythonToCpp_PyObject_PTR_Convertible(PyObject * /* pyIn */)
-{
-    return PyObject_PythonToCpp_PyObject_PTR;
-}
-static PyObject *PyObject_PTR_CppToPython_PyObject(const void *cppIn)
+static PyObject *CopyCppToPythonPyObject(const void *cppIn)
 {
-    auto *pyOut = reinterpret_cast<PyObject *>(const_cast<void *>(cppIn));
-    if (pyOut)
-        Py_INCREF(pyOut);
+    const auto *wrapper = reinterpret_cast<const PyObjectWrapper *>(cppIn);
+    PyObject *pyOut = *wrapper;
+    Py_XINCREF(pyOut);
     return pyOut;
 }
 
@@ -260,13 +294,16 @@ void SignalManager::init()
     using namespace Shiboken;
 
     // Register PyObject type to use in queued signal and slot connections
-    qRegisterMetaType<PyObjectWrapper>("PyObject");
+    pyObjectWrapperMetaTypeId = qRegisterMetaType<PyObjectWrapper>("PyObject");
     // Register QVariant(enum) conversion to QVariant(int)
     QMetaType::registerConverter<PyObjectWrapper, int>(&PyObjectWrapper::toInt);
 
-    SbkConverter *converter = Shiboken::Conversions::createConverter(&PyBaseObject_Type, nullptr);
-    Shiboken::Conversions::setCppPointerToPythonFunction(converter, PyObject_PTR_CppToPython_PyObject);
-    Shiboken::Conversions::setPythonToCppPointerFunctions(converter, PyObject_PythonToCpp_PyObject_PTR, is_PyObject_PythonToCpp_PyObject_PTR_Convertible);
+    // Register a shiboken converter for PyObjectWrapper->Python (value conversion).
+    // Python->PyObjectWrapper is not registered since the converters do not work for
+    // non-SbkObject types (falling back to plain pointer pass through).
+    // This conversion needs to be done manually via QVariant.
+    SbkConverter *converter = Shiboken::Conversions::createConverter(&PyBaseObject_Type,
+                                                                     CopyCppToPythonPyObject);
     Shiboken::Conversions::registerConverterName(converter, "PyObject");
     Shiboken::Conversions::registerConverterName(converter, "object");
     Shiboken::Conversions::registerConverterName(converter, "PyObjectWrapper");
diff --git a/sources/pyside6/libpyside/signalmanager.h b/sources/pyside6/libpyside/signalmanager.h
index d5c007dbe..9fe56efc2 100644
--- a/sources/pyside6/libpyside/signalmanager.h
+++ b/sources/pyside6/libpyside/signalmanager.h
@@ -14,6 +14,7 @@
 #include <optional>
 
 QT_FORWARD_DECLARE_CLASS(QDataStream)
+QT_FORWARD_DECLARE_CLASS(QDebug)
 
 namespace PySide
 {
@@ -22,13 +23,13 @@ namespace PySide
 class PYSIDE_API PyObjectWrapper
 {
 public:
-    PyObjectWrapper(PyObjectWrapper&&) = delete;
-    PyObjectWrapper& operator=(PyObjectWrapper &&) = delete;
 
     PyObjectWrapper();
     explicit PyObjectWrapper(PyObject* me);
     PyObjectWrapper(const PyObjectWrapper &other);
     PyObjectWrapper& operator=(const PyObjectWrapper &other);
+    PyObjectWrapper(PyObjectWrapper&&) noexcept;
+    PyObjectWrapper &operator=(PyObjectWrapper &&) noexcept;
 
     void reset(PyObject *o);
 
@@ -43,12 +44,15 @@ public:
     // The proper fix would be to associate PyObjectWrapper to the corresponding C++ Enum.
     int toInt() const;
 
+    static int metaTypeId();
+
 private:
     PyObject* m_me;
 };
 
 PYSIDE_API QDataStream &operator<<(QDataStream& out, const PyObjectWrapper& myObj);
 PYSIDE_API QDataStream &operator>>(QDataStream& in, PyObjectWrapper& myObj);
+PYSIDE_API QDebug operator<<(QDebug debug, const PyObjectWrapper &myObj);
 
 class PYSIDE_API SignalManager
 {