shibokenmodule: Expose dumpConverters()

Complements 193769216f60f87feb20bbffa832cc159bbe525c. Add a function
creating a dump of the registered converters and their type names
sorted by associated Python type object.

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

5 files changed, 114 insertions, 0 deletions

diff --git a/sources/shiboken6/doc/shibokenmodule.rst b/sources/shiboken6/doc/shibokenmodule.rst
index 2f1c6d166..3bc4fa6ba 100644
--- a/sources/shiboken6/doc/shibokenmodule.rst
+++ b/sources/shiboken6/doc/shibokenmodule.rst
@@ -125,6 +125,11 @@ To import the module:
 
     Dumps the map of wrappers existing in libshiboken to standard error.
 
+.. function:: dumpConverters()
+
+    Dumps the map of named converters existing in libshiboken to standard
+    error.
+
  .. py:class:: VoidPtr(address, size = -1, writeable = 0)
 
      :param address: (PyBuffer, SbkObject, int, VoidPtr)
diff --git a/sources/shiboken6/libshiboken/sbkconverter.cpp b/sources/shiboken6/libshiboken/sbkconverter.cpp
index 358827aa8..d6056f874 100644
--- a/sources/shiboken6/libshiboken/sbkconverter.cpp
+++ b/sources/shiboken6/libshiboken/sbkconverter.cpp
@@ -12,7 +12,11 @@
 #include "voidptr.h"
 
 #include <string>
+#include <cstring>
+#include <iostream>
 #include <unordered_map>
+#include <map>
+#include <set>
 
 static SbkConverter **PrimitiveTypeConverters;
 
@@ -72,6 +76,99 @@ void init()
     initArrayConverters();
 }
 
+static void dumpPyTypeObject(std::ostream &str, PyTypeObject *t)
+{
+    str << "\nPython type ";
+    if (t == nullptr) {
+        str << "<None>";
+        return;
+    }
+    str << '"' << t->tp_name << '"';
+    if (t->tp_base != nullptr && t->tp_base != &PyBaseObject_Type)
+        str << '(' << t->tp_base->tp_name << ')';
+}
+
+static void dumpSbkConverter(std::ostream &str, const SbkConverter *c)
+{
+    str << "SbkConverter " << static_cast<const void *>(c) << ": ";
+    if (c->pointerToPython != nullptr)
+        str << ", C++ pointer->Python";
+    if (c->copyToPython != nullptr)
+        str << ", copy->Python";
+    if (c->toCppPointerConversion.second != nullptr)
+        str << ", Python->C++ pointer";
+    if (!c->toCppConversions.empty())
+        str << ", " << c->toCppConversions.size() << " Python->C++ conversions";
+}
+
+// Less than operator for a PyTypeObject for dumping the converter map
+static bool pyTypeObjectLessThan(const PyTypeObject *t1, const PyTypeObject *t2)
+{
+    const bool isNull1 = t1 == nullptr;
+    const bool isNull2 = t2 == nullptr;
+    if (isNull1 || isNull2)
+        return isNull1 && !isNull2;
+    // Internal types (lower case) first
+    const bool isInternal1 = std::islower(t1->tp_name[0]);
+    const bool isInternal2 = std::islower(t2->tp_name[0]);
+    if (isInternal1 != isInternal2)
+        return !isInternal2;
+    return std::strcmp(t1->tp_name, t2->tp_name) < 0;
+}
+
+void dumpConverters()
+{
+    struct PyTypeObjectLess {
+
+        bool operator()(const PyTypeObject *t1, const PyTypeObject *t2) const {
+            return pyTypeObjectLessThan(t1, t2);
+        }
+    };
+
+    using StringSet = std::set<std::string>;
+    using SbkConverterNamesMap = std::unordered_map<SbkConverter *, StringSet>;
+    using PyTypeObjectConverterMap = std::map<PyTypeObject *, SbkConverterNamesMap,
+                                              PyTypeObjectLess>;
+
+    auto &str = std::cerr;
+
+    // Sort the entries by the associated PyTypeObjects and converters
+    PyTypeObjectConverterMap pyTypeObjectConverterMap;
+    for (const auto &converter : converters) {
+        auto *sbkConverter = converter.second;
+        auto *typeObject = sbkConverter->pythonType;
+        auto typeIt = pyTypeObjectConverterMap.find(typeObject);
+        if (typeIt == pyTypeObjectConverterMap.end())
+            typeIt = pyTypeObjectConverterMap.insert(std::make_pair(typeObject,
+                                                                    SbkConverterNamesMap{})).first;
+        SbkConverterNamesMap &sbkConverterMap = typeIt->second;
+        auto convIt = sbkConverterMap.find(sbkConverter);
+        if (convIt == sbkConverterMap.end())
+            convIt = sbkConverterMap.insert(std::make_pair(sbkConverter,
+                                                           StringSet{})).first;
+        convIt->second.insert(converter.first);
+    }
+
+     for (const auto &tc : pyTypeObjectConverterMap) {
+         dumpPyTypeObject(str, tc.first);
+         str << ", " << tc.second.size() << " converter(s):\n";
+         for (const auto &cn : tc.second) {
+             str << "    ";
+             dumpSbkConverter(str, cn.first);
+             str << ", " << cn.second.size() << " alias(es):";
+             int i = 0;
+             for (const auto &name : cn.second) {
+                 if ((i++ % 5) == 0)
+                     str << "\n        ";
+                 str << " \"" << name << '"';
+             }
+             str << '\n';
+         }
+    }
+
+    str << '\n';
+}
+
 SbkConverter *createConverterObject(PyTypeObject *type,
                                            PythonToCppFunc toCppPointerConvFunc,
                                            IsConvertibleToCppFunc toCppPointerCheckFunc,
diff --git a/sources/shiboken6/libshiboken/sbkconverter_p.h b/sources/shiboken6/libshiboken/sbkconverter_p.h
index c886c9b9f..5d8c1977a 100644
--- a/sources/shiboken6/libshiboken/sbkconverter_p.h
+++ b/sources/shiboken6/libshiboken/sbkconverter_p.h
@@ -531,6 +531,9 @@ SbkConverter *createConverterObject(PyTypeObject *type,
                                     IsConvertibleToCppFunc toCppPointerCheckFunc,
                                     CppToPythonFunc pointerToPythonFunc,
                                     CppToPythonFunc copyToPythonFunc);
+
+LIBSHIBOKEN_API void dumpConverters();
+
 } // namespace Shiboken::Conversions
 
 #endif // SBK_CONVERTER_P_H
diff --git a/sources/shiboken6/shibokenmodule/shibokenmodule.cpp b/sources/shiboken6/shibokenmodule/shibokenmodule.cpp
index b3adfe78b..5c6219885 100644
--- a/sources/shiboken6/shibokenmodule/shibokenmodule.cpp
+++ b/sources/shiboken6/shibokenmodule/shibokenmodule.cpp
@@ -100,6 +100,10 @@ const bool ok = Shiboken::BindingManager::instance().dumpTypeGraph(%1);
 Shiboken::BindingManager::instance().dumpWrapperMap();
 // @snippet dumpwrappermap
 
+// @snippet dumpconverters
+Shiboken::Conversions::dumpConverters();
+// @snippet dumpconverters
+
 // @snippet init
 // Add __version__ and __version_info__ attributes to the module
 PyObject* version = PyTuple_New(5);
diff --git a/sources/shiboken6/shibokenmodule/typesystem_shiboken.xml b/sources/shiboken6/shibokenmodule/typesystem_shiboken.xml
index aa08a8bbf..acb522ecc 100644
--- a/sources/shiboken6/shibokenmodule/typesystem_shiboken.xml
+++ b/sources/shiboken6/shibokenmodule/typesystem_shiboken.xml
@@ -57,9 +57,14 @@
         <inject-code file="shibokenmodule.cpp" snippet="dumpwrappermap"/>
     </add-function>
 
+    <add-function signature="dumpConverters()">
+        <inject-code file="shibokenmodule.cpp" snippet="dumpconverters"/>
+    </add-function>
+
     <extra-includes>
         <include file-name="sbkversion.h" location="local"/>
         <include file-name="voidptr.h" location="local"/>
+        <include file-name="sbkconverter_p.h" location="local"/>
     </extra-includes>
      <inject-code position="end" file="shibokenmodule.cpp" snippet="init"/>
 </typesystem>