diff --git a/sources/pyside2/libpyside/pysidemetafunction.cpp b/sources/pyside2/libpyside/pysidemetafunction.cpp
index 637aa059..3a08974c 100644
--- a/sources/pyside2/libpyside/pysidemetafunction.cpp
+++ b/sources/pyside2/libpyside/pysidemetafunction.cpp
@@ -41,9 +41,12 @@
 #include "pysidemetafunction_p.h"
 
 #include <shiboken.h>
+#include <helper.h>
 #include <signature.h>
 
 #include <QtCore/QMetaMethod>
+#include <QtCore/QDebug>
+#include <iostream>
 
 extern "C"
 {
@@ -135,8 +138,11 @@ PySideMetaFunction *newObject(QObject *source, int methodIndex)
 bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
 {
 
+
     QMetaMethod method = self->metaObject()->method(methodIndex);
     QList<QByteArray> argTypes = method.parameterTypes();
+    qDebug() << __FUNCTION__ << self << method.methodSignature() << argTypes;
+    std::cerr <<  __FUNCTION__ << ' ' << Shiboken::debugPyObject(args)<< '\n';
 
     // args given plus return type
     Shiboken::AutoDecRef sequence(PySequence_Fast(args, 0));
@@ -169,6 +175,7 @@ bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
     int i;
     for (i = 0; i < numArgs; ++i) {
         const QByteArray &typeName = argTypes.at(i);
+         qDebug() << __FUNCTION__ << i << typeName;
         // This must happen only when the method hasn't return type.
         if (typeName.isEmpty()) {
             methArgs[i] = 0;
@@ -178,13 +185,16 @@ bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
         Shiboken::Conversions::SpecificConverter converter(typeName);
         if (converter) {
             int typeId = QMetaType::type(typeName);
-            if (!Shiboken::Conversions::pythonTypeIsObjectType(converter)) {
+            bool isot = Shiboken::Conversions::pythonTypeIsObjectType(converter);
+            qDebug() << __FUNCTION__ << i << typeName << "typeId=" << typeId << "pythonTypeIsObjectType=" << isot;
+            if (!isot) {
                 if (!typeId) {
                     PyErr_Format(PyExc_TypeError, "Value types used on meta functions (including signals) need to be "
                                                   "registered on meta type: %s", typeName.data());
                     break;
                 }
                 methValues[i] = QVariant(typeId, static_cast<const void *>(0));
+                qDebug() << __FUNCTION__ << i << typeName << "typeId=" << typeId << "dflt=" << methValues[i];
             }
             methArgs[i] = methValues[i].data();
             if (i == 0) // Don't do this for return type
@@ -194,7 +204,14 @@ bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
                 converter.toCpp(PySequence_Fast_GET_ITEM(sequence.object(), i - 1), &tmp);
                 methValues[i] = tmp;
             } else {
-                converter.toCpp(PySequence_Fast_GET_ITEM(sequence.object(), i - 1), methArgs[i]);
+                auto seqo = PySequence_Fast_GET_ITEM(sequence.object(), i - 1);
+                std::cerr <<  __FUNCTION__ << ' ' << i << ' ' << Shiboken::debugPyObject(seqo)<< '\n';
+                converter.toCpp(seqo, methArgs[i]);
+            }
+            qDebug() << __FUNCTION__ << i << "qvar=" << methValues[i] << methArgs[i];
+            if (typeId == QMetaType::QObjectStar) {
+                void *vData =methArgs[i];
+                qDebug() << __FUNCTION__ << "QObject" << *((QObject **)vData);
             }
         } else {
             PyErr_Format(PyExc_TypeError, "Unknown type used to call meta function (that may be a signal): %s", argTypes[i].constData());
@@ -203,9 +220,11 @@ bool call(QObject *self, int methodIndex, PyObject *args, PyObject **retVal)
     }
 
     bool ok = i == numArgs;
+    qDebug() << __FUNCTION__ << "i=" << i << "numArgs=" << numArgs << ok;
     if (ok) {
         Py_BEGIN_ALLOW_THREADS
-        QMetaObject::metacall(self, QMetaObject::InvokeMetaMethod, method.methodIndex(), methArgs);
+        int res = QMetaObject::metacall(self, QMetaObject::InvokeMetaMethod, method.methodIndex(), methArgs);
+        qDebug() << __FUNCTION__ << "QMetaObject::metacall rets" << res;
         Py_END_ALLOW_THREADS
 
         if (retVal) {
diff --git a/sources/pyside2/libpyside/pysidesignal.cpp b/sources/pyside2/libpyside/pysidesignal.cpp
index be4c367f..f981288b 100644
--- a/sources/pyside2/libpyside/pysidesignal.cpp
+++ b/sources/pyside2/libpyside/pysidesignal.cpp
@@ -48,9 +48,12 @@
 #include <QtCore/QObject>
 #include <QtCore/QMetaMethod>
 #include <QtCore/QMetaObject>
+#include <QtCore/QDebug>
 #include <signature.h>
+#include <helper.h>
 
 #include <algorithm>
+#include <iostream>
 #include <utility>
 
 #define QT_SIGNAL_SENTINEL '2'
@@ -313,6 +316,7 @@ void signalInstanceFree(void *self)
 
 PyObject *signalInstanceConnect(PyObject *self, PyObject *args, PyObject *kwds)
 {
+    std::cerr << __FUNCTION__ << ' ' << Shiboken::debugPyObject(args) << '\n';
     PyObject *slot = nullptr;
     PyObject *type = nullptr;
     static const char *kwlist[] = {"slot", "type", nullptr};
@@ -438,6 +442,7 @@ int argCountInSignature(const char *signature)
 
 PyObject *signalInstanceEmit(PyObject *self, PyObject *args)
 {
+    std::cerr << __FUNCTION__ << ' ' << Shiboken::debugPyObject(args) << '\n';
     PySideSignalInstance *source = reinterpret_cast<PySideSignalInstance *>(self);
 
     Shiboken::AutoDecRef pyArgs(PyList_New(0));
@@ -470,6 +475,10 @@ PyObject *signalInstanceEmit(PyObject *self, PyObject *args)
 
     Shiboken::AutoDecRef pyMethod(PyObject_GetAttr(source->d->source,
                                                    PySide::PyName::qtEmit()));
+    std::cerr << __FUNCTION__ << " source=" << Shiboken::debugPyObject(sourceSignature.object())
+                 << " method=" <<  Shiboken::debugPyObject(pyMethod.object())
+                 <<  " pyargs=" << Shiboken::debugPyObject(pyArgs)
+              << '\n';
 
     Shiboken::AutoDecRef tupleArgs(PyList_AsTuple(pyArgs));
     return PyObject_CallObject(pyMethod, tupleArgs);
@@ -477,6 +486,7 @@ PyObject *signalInstanceEmit(PyObject *self, PyObject *args)
 
 PyObject *signalInstanceGetItem(PyObject *self, PyObject *key)
 {
+    std::cerr << __FUNCTION__ << ' ' << Shiboken::debugPyObject(key) << '\n';
     auto data = reinterpret_cast<PySideSignalInstance *>(self);
     const auto sigName = data->d->signalName;
     const auto sigKey = PySide::Signal::parseSignature(key);
@@ -485,6 +495,7 @@ PyObject *signalInstanceGetItem(PyObject *self, PyObject *key)
         if (data->d->signature == sig) {
             PyObject *result = reinterpret_cast<PyObject *>(data);
             Py_INCREF(result);
+            std::cerr << __FUNCTION__ << " rets " << Shiboken::debugPyObject(result) << '\n';
             return result;
         }
         data = data->d->next;
@@ -497,6 +508,7 @@ PyObject *signalInstanceGetItem(PyObject *self, PyObject *key)
 
 PyObject *signalInstanceDisconnect(PyObject *self, PyObject *args)
 {
+    std::cerr << __FUNCTION__ <<  ' ' <<  Shiboken::debugPyObject(args) << '\n';
     auto source = reinterpret_cast<PySideSignalInstance *>(self);
     Shiboken::AutoDecRef pyArgs(PyList_New(0));
 
@@ -550,6 +562,7 @@ PyObject *signalInstanceDisconnect(PyObject *self, PyObject *args)
 
 PyObject *signalCall(PyObject *self, PyObject *args, PyObject *kw)
 {
+    std::cerr << __FUNCTION__ <<  ' ' <<  Shiboken::debugPyObject(args) << '\n';
     auto signal = reinterpret_cast<PySideSignal *>(self);
 
     // Native C++ signals can't be called like functions, thus we throw an exception.
@@ -578,6 +591,7 @@ PyObject *signalCall(PyObject *self, PyObject *args, PyObject *kw)
 
 PyObject *signalInstanceCall(PyObject *self, PyObject *args, PyObject *kw)
 {
+    std::cerr << __FUNCTION__ <<  ' ' <<  Shiboken::debugPyObject(args) << '\n';
     auto PySideSignal = reinterpret_cast<PySideSignalInstance *>(self);
     if (!PySideSignal->d->homonymousMethod) {
         PyErr_SetString(PyExc_TypeError, "native Qt signal is not callable");
@@ -643,6 +657,7 @@ bool checkType(PyObject *pyObj)
 
 void updateSourceObject(PyObject *source)
 {
+    std::cerr << __FUNCTION__ << ' ' << Shiboken::debugPyObject(source) << '\n';
     PyTypeObject *objType = reinterpret_cast<PyTypeObject *>(PyObject_Type(source));
 
     Py_ssize_t pos = 0;
@@ -653,6 +668,7 @@ void updateSourceObject(PyObject *source)
         if (PyObject_TypeCheck(value, PySideSignalTypeF())) {
             Shiboken::AutoDecRef signalInstance(reinterpret_cast<PyObject *>(PyObject_New(PySideSignalInstance, PySideSignalInstanceTypeF())));
             instanceInitialize(signalInstance.cast<PySideSignalInstance *>(), key, reinterpret_cast<PySideSignal *>(value), source, 0);
+            std::cerr << __FUNCTION__ << ' ' << Shiboken::debugPyObject(key) << '\n';
             PyObject_SetAttr(source, key, signalInstance);
         }
     }
@@ -853,6 +869,7 @@ static typename T::value_type join(T t, const char *sep)
 
 static void _addSignalToWrapper(SbkObjectType *wrapperType, const char *signalName, PySideSignal *signal)
 {
+    std::cerr << __FUNCTION__ <<  ' ' <<  signalName << '\n';
     auto typeDict = reinterpret_cast<PyTypeObject *>(wrapperType)->tp_dict;
     PyObject *homonymousMethod;
     if ((homonymousMethod = PyDict_GetItemString(typeDict, signalName))) {
@@ -870,6 +887,7 @@ static bool compareSignals(const SignalSignature &sig1, const SignalSignature &)
 
 void registerSignals(SbkObjectType *pyObj, const QMetaObject *metaObject)
 {
+    std::cerr << __FUNCTION__ <<  ' ' << metaObject->className() << '\n';
     typedef QHash<QByteArray, QList<SignalSignature> > SignalSigMap;
     SignalSigMap signalsFound;
     for (int i = metaObject->methodOffset(), max = metaObject->methodCount(); i < max; ++i) {
@@ -946,6 +964,7 @@ QStringList getArgsFromSignature(const char *signature, bool *isShortCircuit)
         types.replace(regex, QLatin1String("\\1"));
         result = types.split(splitRegex);
     }
+     qDebug() << __FUNCTION__ << signature  << result;
     return result;
 }
 
@@ -1012,6 +1031,7 @@ QString getCallbackSignature(const char *signal, QObject *receiver, PyObject *ca
         signature.append(args.join(QLatin1Char(',')));
         signature.append(QLatin1Char(')'));
     }
+    qDebug() << __FUNCTION__ << signal << signature;
     return signature;
 }
 
diff --git a/sources/pyside2/libpyside/signalmanager.cpp b/sources/pyside2/libpyside/signalmanager.cpp
index 8e8cc9f0..7df17cba 100644
--- a/sources/pyside2/libpyside/signalmanager.cpp
+++ b/sources/pyside2/libpyside/signalmanager.cpp
@@ -53,6 +53,8 @@
 #include <gilstate.h>
 #include <sbkconverter.h>
 #include <sbkstring.h>
+#include <helper.h>
+
 #include <sbkstaticstrings.h>
 
 #include <QtCore/QDebug>
@@ -60,6 +62,7 @@
 
 #include <algorithm>
 #include <limits>
+#include <iostream>
 
 // These private headers are needed to throw JavaScript exceptions
 #if PYSIDE_QML_PRIVATE_API_SUPPORT
@@ -360,26 +363,32 @@ int SignalManager::globalReceiverSlotIndex(QObject *receiver, const char *signat
 
 bool SignalManager::emitSignal(QObject *source, const char *signal, PyObject *args)
 {
+     qDebug()  << __FUNCTION__ << source<< signal;
+     std::cerr << "    args= " << Shiboken::debugPyObject(args) << '\n';
     if (!Signal::checkQtSignal(signal))
         return false;
     signal++;
 
     int signalIndex = source->metaObject()->indexOfSignal(signal);
+    bool r = false;
     if (signalIndex != -1) {
         // cryptic but works!
         // if the signature doesn't have a '(' it's a shor circuited signal, i.e. std::find
         // returned the string null terminator.
         bool isShortCircuit = !*std::find(signal, signal + std::strlen(signal), '(');
+        qDebug() << __FUNCTION__ << " idx = " << signalIndex << " isShortCircuit=" << isShortCircuit;
         if (isShortCircuit)
-            return emitShortCircuitSignal(source, signalIndex, args);
+            r = emitShortCircuitSignal(source, signalIndex, args);
         else
-            return MetaFunction::call(source, signalIndex, args);
+            r = MetaFunction::call(source, signalIndex, args);
     }
-    return false;
+    qDebug() << __FUNCTION__ << source<< signal << " rets = " << r;
+    return r;
 }
 
 int SignalManager::qt_metacall(QObject *object, QMetaObject::Call call, int id, void **args)
 {
+    qDebug() << '>' << __FUNCTION__ << object << call << id;
     const QMetaObject *metaObject = object->metaObject();
     PySideProperty *pp = nullptr;
     PyObject *pp_name = nullptr;
@@ -507,12 +516,15 @@ int SignalManager::qt_metacall(QObject *object, QMetaObject::Call call, int id,
         }
     }
 
+    qDebug() << '<' << __FUNCTION__ << object << "rets" << id;
     return id;
 }
 
 int SignalManager::callPythonMetaMethod(const QMetaMethod &method, void **args, PyObject *pyMethod, bool isShortCuit)
 {
     Q_ASSERT(pyMethod);
+    std::cerr << __FUNCTION__ << ' ' << method.name().constData() << ' '<< Shiboken::debugPyObject(pyMethod)
+              << " isShortCuit=" << isShortCuit << '\n';
 
     Shiboken::GilState gil;
     PyObject *pyArguments = nullptr;
@@ -521,6 +533,7 @@ int SignalManager::callPythonMetaMethod(const QMetaMethod &method, void **args,
         pyArguments = reinterpret_cast<PyObject *>(args[1]);
     } else {
         pyArguments = parseArguments(method.parameterTypes(), args);
+        std::cerr << __FUNCTION__ << ' ' << Shiboken::debugPyObject(pyArguments) << '\n';
     }
 
     if (pyArguments) {
@@ -642,11 +655,13 @@ namespace {
 
 static int callMethod(QObject *object, int id, void **args)
 {
+    qDebug() << '>' << __FUNCTION__ << id;
     const QMetaObject *metaObject = object->metaObject();
     QMetaMethod method = metaObject->method(id);
 
     if (method.methodType() == QMetaMethod::Signal) {
         // emit python signal
+        qDebug() << __FUNCTION__ << " emit sig ";
         QMetaObject::activate(object, id, args);
     } else {
         Shiboken::GilState gil;
@@ -654,8 +669,11 @@ static int callMethod(QObject *object, int id, void **args)
         QByteArray methodName = method.methodSignature();
         methodName.truncate(methodName.indexOf('('));
         Shiboken::AutoDecRef pyMethod(PyObject_GetAttrString(self, methodName));
+        std::cerr << __FUNCTION__ << ' ' << methodName.constData() << ' '
+                  << Shiboken::debugPyObject(pyMethod) << '\n';
         return SignalManager::callPythonMetaMethod(method, args, pyMethod, false);
     }
+    qDebug() << '<' << __FUNCTION__;
     return -1;
 }
 
@@ -663,6 +681,7 @@ static int callMethod(QObject *object, int id, void **args)
 static PyObject *parseArguments(const QList<QByteArray>& paramTypes, void **args)
 {
     int argsSize = paramTypes.count();
+    qDebug() << __FUNCTION__ << ' ' << paramTypes;
     PyObject *preparedArgs = PyTuple_New(argsSize);
 
     for (int i = 0, max = argsSize; i < max; ++i) {
@@ -670,7 +689,9 @@ static PyObject *parseArguments(const QList<QByteArray>& paramTypes, void **args
         const char *dataType = paramTypes[i].constData();
         Shiboken::Conversions::SpecificConverter converter(dataType);
         if (converter) {
-            PyTuple_SET_ITEM(preparedArgs, i, converter.toPython(data));
+            auto p = converter.toPython(data);
+            std::cerr << __FUNCTION__ << ' ' << i <<  ' ' << Shiboken::debugPyObject(p) << '\n';
+            PyTuple_SET_ITEM(preparedArgs, i, p);
         } else {
             PyErr_Format(PyExc_TypeError, "Can't call meta function because I have no idea how to handle %s", dataType);
             Py_DECREF(preparedArgs);
@@ -682,6 +703,8 @@ static PyObject *parseArguments(const QList<QByteArray>& paramTypes, void **args
 
 static bool emitShortCircuitSignal(QObject *source, int signalIndex, PyObject *args)
 {
+    qDebug() << __FUNCTION__ << ' ' << signalIndex;
+
     void *signalArgs[2] = {nullptr, args};
     source->qt_metacall(QMetaObject::InvokeMetaMethod, signalIndex, signalArgs);
     return true;
