1 files changed, 16 insertions, 16 deletions

diff --git a/sources/shiboken2/libshiboken/basewrapper.cpp b/sources/shiboken2/libshiboken/basewrapper.cpp
index 43c162dec..ec705a421 100644
--- a/sources/shiboken2/libshiboken/basewrapper.cpp
+++ b/sources/shiboken2/libshiboken/basewrapper.cpp
@@ -180,8 +180,8 @@ SbkObjectType *SbkObject_TypeF(void)
         type = reinterpret_cast<PyTypeObject *>(PyType_FromSpec(&SbkObject_Type_spec));
         Py_TYPE(type) = SbkObjectType_TypeF();
         Py_INCREF(Py_TYPE(type));
-        PepType(type)->tp_weaklistoffset = offsetof(SbkObject, weakreflist);
-        PepType(type)->tp_dictoffset = offsetof(SbkObject, ob_dict);
+        type->tp_weaklistoffset = offsetof(SbkObject, weakreflist);
+        type->tp_dictoffset = offsetof(SbkObject, ob_dict);
     }
     return reinterpret_cast<SbkObjectType *>(type);
 }
@@ -306,18 +306,18 @@ PyObject* SbkObjectTypeTpNew(PyTypeObject* metatype, PyObject* args, PyObject* k
 #ifndef IS_PY3K
         if (PyClass_Check(baseType)) {
             PyErr_Format(PyExc_TypeError, "Invalid base class used in type %s. "
-                "PySide only support multiple inheritance from python new style class.", PepType(metatype)->tp_name);
+                "PySide only support multiple inheritance from python new style class.", metatype->tp_name);
             return 0;
         }
 #endif
-        if (PepType(reinterpret_cast<PyTypeObject*>(baseType))->tp_new == SbkDummyNew) {
+        if (reinterpret_cast<PyTypeObject *>(baseType)->tp_new == SbkDummyNew) {
             // PYSIDE-595: A base class does not allow inheritance.
             return SbkDummyNew(metatype, args, kwds);
         }
     }
 
     // The meta type creates a new type when the Python programmer extends a wrapped C++ class.
-    newfunc type_new = reinterpret_cast<newfunc>(PepType(&PyType_Type)->tp_new);
+    newfunc type_new = reinterpret_cast<newfunc>(PyType_Type.tp_new);
     SbkObjectType *newType = reinterpret_cast<SbkObjectType*>(type_new(metatype, args, kwds));
     if (!newType)
         return 0;
@@ -425,7 +425,7 @@ SbkDummyNew(PyTypeObject *type, PyObject*, PyObject*)
     // PYSIDE-595: Give the same error as type_call does when tp_new is NULL.
     PyErr_Format(PyExc_TypeError,
                  "cannot create '%.100s' instances ¯\\_(ツ)_/¯",
-                 PepType(type)->tp_name);
+                 type->tp_name);
     return nullptr;
 }
 
@@ -458,7 +458,7 @@ static void decRefPyObjectList(const std::list<PyObject*> &pyObj, PyObject* skip
 
 static void _walkThroughClassHierarchy(PyTypeObject* currentType, HierarchyVisitor* visitor)
 {
-    PyObject* bases = PepType(currentType)->tp_bases;
+    PyObject* bases = currentType->tp_bases;
     Py_ssize_t numBases = PyTuple_GET_SIZE(bases);
     for (int i = 0; i < numBases; ++i) {
         PyTypeObject* type = reinterpret_cast<PyTypeObject*>(PyTuple_GET_ITEM(bases, i));
@@ -577,10 +577,10 @@ void setErrorAboutWrongArguments(PyObject* args, const char* funcName, const cha
                 if (i)
                     params += ", ";
                 PyObject* arg = PyTuple_GET_ITEM(args, i);
-                params += PepType((Py_TYPE(arg)))->tp_name;
+                params += Py_TYPE(arg)->tp_name;
             }
         } else {
-            params = PepType((Py_TYPE(args)))->tp_name;
+            params = Py_TYPE(args)->tp_name;
         }
     }
 
@@ -669,7 +669,7 @@ bool canCallConstructor(PyTypeObject* myType, PyTypeObject* ctorType)
     FindBaseTypeVisitor visitor(ctorType);
     walkThroughClassHierarchy(myType, &visitor);
     if (!visitor.found()) {
-        PyErr_Format(PyExc_TypeError, "%s isn't a direct base class of %s", PepType(ctorType)->tp_name, PepType(myType)->tp_name);
+        PyErr_Format(PyExc_TypeError, "%s isn't a direct base class of %s", ctorType->tp_name, myType->tp_name);
         return false;
     }
     return true;
@@ -1105,13 +1105,13 @@ bool isValid(PyObject* pyObj)
 
     if (!priv->cppObjectCreated && isUserType(pyObj)) {
         PyErr_Format(PyExc_RuntimeError, "'__init__' method of object's base class (%s) not called.",
-                     PepType((Py_TYPE(pyObj)))->tp_name);
+                     Py_TYPE(pyObj)->tp_name);
         return false;
     }
 
     if (!priv->validCppObject) {
         PyErr_Format(PyExc_RuntimeError, "Internal C++ object (%s) already deleted.",
-                     PepType((Py_TYPE(pyObj)))->tp_name);
+                     Py_TYPE(pyObj)->tp_name);
         return false;
     }
 
@@ -1127,14 +1127,14 @@ bool isValid(SbkObject* pyObj, bool throwPyError)
     if (!priv->cppObjectCreated && isUserType(reinterpret_cast<PyObject*>(pyObj))) {
         if (throwPyError)
             PyErr_Format(PyExc_RuntimeError, "Base constructor of the object (%s) not called.",
-                         PepType((Py_TYPE(pyObj)))->tp_name);
+                         Py_TYPE(pyObj)->tp_name);
         return false;
     }
 
     if (!priv->validCppObject) {
         if (throwPyError)
             PyErr_Format(PyExc_RuntimeError, "Internal C++ object (%s) already deleted.",
-                         PepType((Py_TYPE(pyObj)))->tp_name);
+                         (Py_TYPE(pyObj))->tp_name);
         return false;
     }
 
@@ -1415,7 +1415,7 @@ void deallocData(SbkObject* self, bool cleanup)
 
     // PYSIDE-571: qApp is no longer allocated.
     if (PyObject_IS_GC(reinterpret_cast<PyObject*>(self)))
-        PepType(Py_TYPE(self))->tp_free(self);
+        Py_TYPE(self)->tp_free(self);
 }
 
 void setTypeUserData(SbkObject* wrapper, void* userData, DeleteUserDataFunc d_func)
@@ -1512,7 +1512,7 @@ std::string info(SbkObject* self)
         s << "C++ address....... ";
         std::list<SbkObjectType*>::const_iterator it = bases.begin();
         for (int i = 0; it != bases.end(); ++it, ++i)
-            s << PepType((reinterpret_cast<PyTypeObject*>(*it)))->tp_name << '/' << self->d->cptr[i] << ' ';
+            s << reinterpret_cast<PyTypeObject *>(*it)->tp_name << '/' << self->d->cptr[i] << ' ';
         s << "\n";
     }
     else {