libshiboken: Split the Shiboken::Object::newObject() function

Remove the bool exactType parameter from the existing
newObject() by splitting it into 3 functions:

newObjectForType() creates an instance for the type passed in.

newObjectWithHeuristics() takes an additional typeName
parameter obtained from typeid().name() on the C++ pointer which
may contain the derived class name and also tries to find
the most derived class using the type discovery graph.

newObjectForPointer() is new and contains a test for multiple
inheritance in the inheritance tree (disabling use of the most derived
class) which was previously generated into the code.

Change-Id: Ic0a25f8ec17dc20364b37062de6f20544cd2f09e
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>

4 files changed, 107 insertions, 31 deletions

diff --git a/sources/pyside6/libpyside/pyside.cpp b/sources/pyside6/libpyside/pyside.cpp
index d5e815a42..cff74c260 100644
--- a/sources/pyside6/libpyside/pyside.cpp
+++ b/sources/pyside6/libpyside/pyside.cpp
@@ -738,7 +738,7 @@ PyObject *getWrapperForQObject(QObject *cppSelf, PyTypeObject *sbk_type)
         }
     }
 
-    pyOut = Shiboken::Object::newObject(sbk_type, cppSelf, false, false, typeName(cppSelf));
+    pyOut = Shiboken::Object::newObjectWithHeuristics(sbk_type, cppSelf, false, typeName(cppSelf));
 
     return pyOut;
 }
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index 84d3c93d3..494d914c1 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -1590,6 +1590,27 @@ void CppGenerator::writeEnumConverterFunctions(TextStream &s, const AbstractMeta
     s << '\n';
 }
 
+static void writePointerToPythonConverter(TextStream &c,
+                                          const AbstractMetaClassCPtr &metaClass,
+                                          const QString &typeName,
+                                          const QString &cpythonType)
+{
+    c << "auto *pyOut = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(cppIn));\n"
+        << "if (pyOut) {\n" << indent
+        << "Py_INCREF(pyOut);\nreturn pyOut;\n" << outdent
+        << "}\n"
+        << "auto *tCppIn = reinterpret_cast<const " << typeName << R"( *>(cppIn);
+const char *typeName = )";
+
+    const QString nameFunc = metaClass->typeEntry()->polymorphicNameFunction();
+    if (nameFunc.isEmpty())
+        c << "typeid(*tCppIn).name();\n";
+    else
+        c << nameFunc << "(tCppIn);\n";
+    c << "return Shiboken::Object::newObjectForPointer("
+        << cpythonType << ", const_cast<void *>(cppIn), false, typeName);\n";
+}
+
 void CppGenerator::writeConverterFunctions(TextStream &s, const AbstractMetaClassCPtr &metaClass,
                                            const GeneratorContext &classContext) const
 {
@@ -1635,26 +1656,7 @@ void CppGenerator::writeConverterFunctions(TextStream &s, const AbstractMetaClas
         c << "return PySide::getWrapperForQObject(reinterpret_cast<"
             << typeName << " *>(const_cast<void *>(cppIn)), " << cpythonType << ");\n";
     } else {
-        c << "auto *pyOut = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(cppIn));\n"
-            << "if (pyOut) {\n" << indent
-            << "Py_INCREF(pyOut);\nreturn pyOut;\n" << outdent
-            << "}\n"
-            << "bool exactType = false;\n"
-            << "auto *tCppIn = reinterpret_cast<const " << typeName << R"( *>(cppIn);
-const char *typeName = )";
-
-        const QString nameFunc = metaClass->typeEntry()->polymorphicNameFunction();
-        if (nameFunc.isEmpty())
-            c << "typeid(*tCppIn).name();\n";
-        else
-            c << nameFunc << "(tCppIn);\n";
-        c << R"(auto *sbkType = Shiboken::ObjectType::typeForTypeName(typeName);
-if (sbkType != nullptr && Shiboken::ObjectType::hasSpecialCastFunction(sbkType))
-    exactType = true;
-)"
-            << "PyObject *result = Shiboken::Object::newObject(" << cpythonType
-            << R"(, const_cast<void *>(cppIn), false, exactType, typeName);
-return result;)";
+        writePointerToPythonConverter(c, metaClass, typeName, cpythonType);
     }
     std::swap(targetTypeName, sourceTypeName);
     writeCppToPythonFunction(s, c.toString(), sourceTypeName, targetTypeName);
diff --git a/sources/shiboken6/libshiboken/basewrapper.cpp b/sources/shiboken6/libshiboken/basewrapper.cpp
index 6c1d4bf1f..61e824f64 100644
--- a/sources/shiboken6/libshiboken/basewrapper.cpp
+++ b/sources/shiboken6/libshiboken/basewrapper.cpp
@@ -1424,25 +1424,64 @@ SbkObject *findColocatedChild(SbkObject *wrapper,
     return nullptr;
 }
 
+// Legacy, for compatibility only.
 PyObject *newObject(PyTypeObject *instanceType,
                     void *cptr,
                     bool hasOwnership,
                     bool isExactType,
                     const char *typeName)
 {
+    return isExactType
+        ? newObjectForType(instanceType, cptr, hasOwnership)
+        : newObjectWithHeuristics(instanceType, cptr, hasOwnership, typeName);
+}
+
+static PyObject *newObjectWithHeuristicsHelper(PyTypeObject *instanceType,
+                                               PyTypeObject *exactType,
+                                               void *cptr,
+                                               bool hasOwnership)
+{
     // Try to find the exact type of cptr.
-    if (!isExactType) {
-        if (PyTypeObject *exactType = ObjectType::typeForTypeName(typeName)) {
-            instanceType = exactType;
-        } else {
-            auto resolved = BindingManager::instance().findDerivedType(cptr, instanceType);
-            if (resolved.first != nullptr) {
-                instanceType = resolved.first;
-                cptr = resolved.second;
-            }
+    if (exactType == nullptr) {
+        auto resolved = BindingManager::instance().findDerivedType(cptr, instanceType);
+        if (resolved.first != nullptr) {
+            exactType = resolved.first;
+            cptr = resolved.second;
         }
     }
 
+    return newObjectForType(exactType != nullptr ? exactType : instanceType,
+                            cptr, hasOwnership);
+}
+
+PyObject *newObjectForPointer(PyTypeObject *instanceType,
+                              void *cptr,
+                              bool hasOwnership,
+                              const char *typeName)
+{
+    // Try to find the exact type of cptr.
+    PyTypeObject *exactType = ObjectType::typeForTypeName(typeName);
+    // PYSIDE-868: In case of multiple inheritance, (for example,
+    // a function returning a QPaintDevice * from a QWidget *),
+    // use instance type to avoid pointer offset errors.
+    return exactType != nullptr && Shiboken::ObjectType::hasSpecialCastFunction(exactType)
+        ? newObjectForType(instanceType, cptr, hasOwnership)
+        : newObjectWithHeuristicsHelper(instanceType, exactType, cptr, hasOwnership);
+}
+
+
+PyObject *newObjectWithHeuristics(PyTypeObject *instanceType,
+                                  void *cptr,
+                                  bool hasOwnership,
+                                  const char *typeName)
+{
+    return newObjectWithHeuristicsHelper(instanceType,
+                                         ObjectType::typeForTypeName(typeName),
+                                         cptr, hasOwnership);
+}
+
+PyObject *newObjectForType(PyTypeObject *instanceType, void *cptr, bool hasOwnership)
+{
     bool shouldCreate = true;
     bool shouldRegister = true;
     SbkObject *self = nullptr;
diff --git a/sources/shiboken6/libshiboken/basewrapper.h b/sources/shiboken6/libshiboken/basewrapper.h
index 4835c4810..ecbb20f4e 100644
--- a/sources/shiboken6/libshiboken/basewrapper.h
+++ b/sources/shiboken6/libshiboken/basewrapper.h
@@ -297,7 +297,8 @@ LIBSHIBOKEN_API SbkObject *findColocatedChild(SbkObject *wrapper,
                                               const PyTypeObject *instanceType);
 
 /**
- *  Bind a C++ object to Python.
+ *  Bind a C++ object to Python. Forwards to
+ *  newObjectWithHeuristics(), newObjectForType() depending on \p isExactType.
  * \param instanceType equivalent Python type for the C++ object.
  * \param hasOwnership if true, Python will try to delete the underlying C++ object when there's no more refs.
  * \param isExactType if false, Shiboken will use some heuristics to detect the correct Python type of this C++
@@ -311,6 +312,40 @@ LIBSHIBOKEN_API PyObject *newObject(PyTypeObject *instanceType,
                                     bool isExactType = false,
                                     const char *typeName = nullptr);
 
+/// Bind a C++ object to Python for polymorphic pointers. Calls
+/// newObjectWithHeuristics() with an additional check for multiple
+/// inheritance, in which case it will fall back to instanceType.
+/// \param instanceType Equivalent Python type for the C++ object.
+/// \param hasOwnership if true, Python will try to delete the underlying C++ object
+///                     when there's no more refs.
+/// \param typeName     If non-null, this will be used as helper to find the correct
+///                     Python type for this object (obtained by typeid().name().
+LIBSHIBOKEN_API PyObject *newObjectForPointer(PyTypeObject *instanceType,
+                                              void *cptr,
+                                              bool hasOwnership = true,
+                                              const char *typeName = nullptr);
+
+/// Bind a C++ object to Python using some heuristics to detect the correct
+/// Python type of this C++ object. In any case \p instanceType must be provided;
+/// it'll be used as search starting point and as fallback.
+/// \param instanceType Equivalent Python type for the C++ object.
+/// \param hasOwnership if true, Python will try to delete the underlying C++ object
+///                     C++ object when there are no more references.
+///                     when there's no more refs.
+/// \param typeName     If non-null, this will be used as helper to find the correct
+///                     Python type for this object (obtained by typeid().name().
+LIBSHIBOKEN_API PyObject *newObjectWithHeuristics(PyTypeObject *instanceType,
+                                                  void *cptr,
+                                                  bool hasOwnership = true,
+                                                  const char *typeName = nullptr);
+
+/// Bind a C++ object to Python using the given type.
+/// \param instanceType Equivalent Python type for the C++ object.
+/// \param hasOwnership if true, Python will try to delete the underlying
+///                     C++ object when there are no more references.
+LIBSHIBOKEN_API PyObject *newObjectForType(PyTypeObject *instanceType,
+                                           void *cptr, bool hasOwnership = true);
+
 /**
  *  Changes the valid flag of a PyObject, invalid objects will raise an exception when someone tries to access it.
  */