shiboken6: Consolidate type name utility headers

- Rename CPython types to cPy*
- Use them where applicable

Change-Id: Iea05f7d7de5402b9de6d8a614da899b0b67811dc
Reviewed-by: Christian Tismer <tismer@stackless.com>
(cherry picked from commit 0e055a163c8b81b74ea90180f910827f507fe10e)

6 files changed, 48 insertions, 49 deletions

diff --git a/sources/shiboken6/ApiExtractor/typesystem.cpp b/sources/shiboken6/ApiExtractor/typesystem.cpp
index b76582b9f..0a1f4b888 100644
--- a/sources/shiboken6/ApiExtractor/typesystem.cpp
+++ b/sources/shiboken6/ApiExtractor/typesystem.cpp
@@ -36,12 +36,6 @@
 #include <QtCore/QRegularExpression>
 #include <QtCore/QSet>
 
-static QString strings_Object = QLatin1String("Object");
-static QString strings_String = QLatin1String("String");
-static QString strings_char = QLatin1String("char");
-static QString strings_jchar = QLatin1String("jchar");
-static QString strings_jobject = QLatin1String("jobject");
-
 static QString buildName(const QString &entryName, const TypeEntry *parent)
 {
     return parent == nullptr || parent->type() == TypeEntry::TypeSystemType
@@ -1187,7 +1181,7 @@ bool ComplexTypeEntry::isComplex() const
 
 QString ComplexTypeEntry::targetLangApiName() const
 {
-    return strings_jobject;
+    return QStringLiteral("jobject");
 }
 
 void ComplexTypeEntry::setTypeFlags(TypeFlags flags)
diff --git a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
index 74badd024..a677f3e46 100644
--- a/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken6/generator/qtdoc/qtdocgenerator.cpp
@@ -31,6 +31,7 @@
 #include "qtxmltosphinx.h"
 #include "rstformat.h"
 #include "ctypenames.h"
+#include "pytypenames.h"
 #include <abstractmetaenum.h>
 #include <abstractmetafield.h>
 #include <abstractmetafunction.h>
@@ -650,20 +651,19 @@ QString QtDocGenerator::functionSignature(const AbstractMetaClass* cppClass,
 QString QtDocGenerator::translateToPythonType(const AbstractMetaType &type,
                                               const AbstractMetaClass* cppClass) const
 {
-    static const QStringList nativeTypes = {boolT(), floatT(), intT(),
-        QLatin1String("object"),
-        QLatin1String("str")
-    };
+    static const QStringList nativeTypes =
+        {boolT(), floatT(), intT(), pyObjectT(), pyStrT()};
+
     const QString name = type.name();
     if (nativeTypes.contains(name))
         return name;
 
     static const QMap<QString, QString> typeMap = {
-        { QLatin1String("PyObject"), QLatin1String("object") },
-        { QLatin1String("QString"), QLatin1String("str") },
-        { QLatin1String("uchar"), QLatin1String("str") },
+        { cPyObjectT(), pyObjectT() },
+        { qStringT(), pyStrT() },
+        { QLatin1String("uchar"), pyStrT() },
         { QLatin1String("QStringList"), QLatin1String("list of strings") },
-        { qVariantT(), QLatin1String("object") },
+        { qVariantT(), pyObjectT() },
         { QLatin1String("quint32"), intT() },
         { QLatin1String("uint32_t"), intT() },
         { QLatin1String("quint64"), intT() },
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index 3168490aa..45d0d072d 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -1129,7 +1129,7 @@ void CppGenerator::writeVirtualMethodNative(TextStream &s,
             if (invalidateReturn)
                 s << "bool invalidateArg0 = " << PYTHON_RETURN_VAR << "->ob_refcnt == 1;\n";
 
-            if (func->typeReplaced(0) != QLatin1String("PyObject")) {
+            if (func->typeReplaced(0) != cPyObjectT()) {
 
                 s << "// Check return type\n";
                 if (func->typeReplaced(0).isEmpty()) {
@@ -2445,9 +2445,9 @@ static const QStringList &knownPythonTypes()
 {
     static const QStringList result = {
         pyBoolT(), pyIntT(), pyFloatT(), pyLongT(),
-        QLatin1String("PyObject"), QLatin1String("PyString"),
-        QLatin1String("PyBuffer"), QLatin1String("PySequence"),
-        QLatin1String("PyTuple"), QLatin1String("PyList"),
+        cPyObjectT(), QLatin1String("PyString"),
+        cPyBufferT(), cPySequenceT(),
+        QLatin1String("PyTuple"), cPyListT(),
         QLatin1String("PyDict"), QLatin1String("PyObject*"),
         QLatin1String("PyObject *"), QLatin1String("PyTupleObject*")};
     return result;
@@ -2786,7 +2786,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(TextStream &s,
         int startArg = od->argPos();
         int sequenceArgCount = 0;
         while (od && !od->argType().isVarargs()) {
-            bool typeReplacedByPyObject = od->argumentTypeReplaced() == QLatin1String("PyObject");
+            bool typeReplacedByPyObject = od->argumentTypeReplaced() == cPyObjectT();
             if (!typeReplacedByPyObject) {
                 if (usePyArgs)
                     pyArgName = pythonArgsAt(od->argPos());
@@ -3149,12 +3149,12 @@ void CppGenerator::writePythonToCppConversionFunctions(TextStream &s,
             typeCheck = QLatin1String("Shiboken::isShibokenEnum(%in)");
         else if (pyTypeName == QLatin1String("SbkObject"))
             typeCheck = QLatin1String("Shiboken::Object::checkType(%in)");
-        else if (pyTypeName == QLatin1String("PyTypeObject"))
+        else if (pyTypeName == cPyTypeObjectT())
             typeCheck = QLatin1String("PyType_Check(%in)");
-        else if (pyTypeName == QLatin1String("PyObject"))
+        else if (pyTypeName == cPyObjectT())
             typeCheck = QLatin1String("PyObject_TypeCheck(%in, &PyBaseObject_Type)");
         // PYSIDE-795: We abuse PySequence for iterables
-        else if (pyTypeName == QLatin1String("PySequence"))
+        else if (pyTypeName == cPySequenceT())
             typeCheck = QLatin1String("Shiboken::String::checkIterable(%in)");
         else if (pyTypeName.startsWith(QLatin1String("Py")))
             typeCheck = pyTypeName + QLatin1String("_Check(%in)");
@@ -3911,7 +3911,7 @@ void CppGenerator::writePrimitiveConverterInitialization(TextStream &s, const Cu
         << converter << " = Shiboken::Conversions::createConverter(";
     if (type->targetLangApiName() == type->name())
         s << '0';
-    else if (type->targetLangApiName() == QLatin1String("PyObject"))
+    else if (type->targetLangApiName() == cPyObjectT())
         s << "&PyBaseObject_Type";
     else
         s << '&' << type->targetLangApiName() << "_Type";
@@ -4007,12 +4007,12 @@ void CppGenerator::writeContainerConverterInitialization(TextStream &s, const Ab
     s << "// Register converter for type '" << cppSignature << "'.\n";
     QString converter = converterObject(type);
     s << converter << " = Shiboken::Conversions::createConverter(";
-    if (type.typeEntry()->targetLangApiName() == QLatin1String("PyObject")) {
+    if (type.typeEntry()->targetLangApiName() == cPyObjectT()) {
         s << "&PyBaseObject_Type";
     } else {
         QString baseName = cpythonBaseName(type.typeEntry());
-        if (baseName == QLatin1String("PySequence"))
-            baseName = QLatin1String("PyList");
+        if (baseName == cPySequenceT())
+            baseName = cPyListT();
         s << '&' << baseName << "_Type";
     }
     QString typeName = fixedCppTypeName(type);
diff --git a/sources/shiboken6/generator/shiboken/overloaddata.cpp b/sources/shiboken6/generator/shiboken/overloaddata.cpp
index b77fa2c57..c1d0ddd42 100644
--- a/sources/shiboken6/generator/shiboken/overloaddata.cpp
+++ b/sources/shiboken6/generator/shiboken/overloaddata.cpp
@@ -34,6 +34,7 @@
 #include <graph.h>
 #include "overloaddata.h"
 #include "ctypenames.h"
+#include "pytypenames.h"
 #include "textstream.h"
 
 #include <QtCore/QDir>
@@ -161,10 +162,6 @@ bool OverloadData::sortByOverloadNumberModification()
     return true;
 }
 
-static inline QString pyObjectT() { return QStringLiteral("PyObject"); }
-static inline QString pySequenceT() { return QStringLiteral("PySequence"); }
-static inline QString pyBufferT() { return QStringLiteral("PyBuffer"); }
-
 using OverloadGraph = Graph<QString>;
 
 /**
@@ -216,11 +213,11 @@ void OverloadData::sortNextOverloads()
             it.value().append(ov);
         }
 
-        if (!checkPyObject && typeName == pyObjectT())
+        if (!checkPyObject && typeName == cPyObjectT())
             checkPyObject = true;
-        else if (!checkPySequence && typeName == pySequenceT())
+        else if (!checkPySequence && typeName == cPySequenceT())
             checkPySequence = true;
-        else if (!checkPyBuffer && typeName == pyBufferT())
+        else if (!checkPyBuffer && typeName == cPyBufferT())
             checkPyBuffer = true;
         else if (!checkQVariant && typeName == qVariantT())
             checkQVariant = true;
@@ -261,7 +258,7 @@ void OverloadData::sortNextOverloads()
     }
 
     if (checkPySequence && checkPyObject)
-        graph.addEdge(pySequenceT(), pyObjectT());
+        graph.addEdge(cPySequenceT(), cPyObjectT());
 
     QStringList classesWithIntegerImplicitConversion;
 
@@ -340,18 +337,18 @@ void OverloadData::sortNextOverloads()
 
 
         if ((checkPySequence || checkPyObject || checkPyBuffer)
-            && !targetTypeEntryName.contains(pyObjectT())
-            && !targetTypeEntryName.contains(pyBufferT())
-            && !targetTypeEntryName.contains(pySequenceT())) {
+            && !targetTypeEntryName.contains(cPyObjectT())
+            && !targetTypeEntryName.contains(cPyBufferT())
+            && !targetTypeEntryName.contains(cPySequenceT())) {
             if (checkPySequence) {
                 // PySequence will be checked after all more specific types, but before PyObject.
-                graph.addEdge(targetTypeEntryName, pySequenceT());
+                graph.addEdge(targetTypeEntryName, cPySequenceT());
             } else if (checkPyBuffer) {
                 // PySequence will be checked after all more specific types, but before PyObject.
-                graph.addEdge(targetTypeEntryName, pyBufferT());
+                graph.addEdge(targetTypeEntryName, cPyBufferT());
             } else {
                 // Add dependency on PyObject, so its check is the last one (too generic).
-                graph.addEdge(targetTypeEntryName, pyObjectT());
+                graph.addEdge(targetTypeEntryName, cPyObjectT());
             }
         } else if (checkQVariant && targetTypeEntryName != qVariantT()) {
             if (!graph.containsEdge(qVariantT(), targetTypeEntryName)) // Avoid cyclic dependency.
@@ -359,7 +356,7 @@ void OverloadData::sortNextOverloads()
         } else if (checkQString && ov->argType().isPointer()
             && targetTypeEntryName != qStringT()
             && targetTypeEntryName != qByteArrayT()
-            && (!checkPyObject || targetTypeEntryName != pyObjectT())) {
+            && (!checkPyObject || targetTypeEntryName != cPyObjectT())) {
             if (!graph.containsEdge(qStringT(), targetTypeEntryName)) // Avoid cyclic dependency.
                 graph.addEdge(targetTypeEntryName, qStringT());
         }
diff --git a/sources/shiboken6/generator/shiboken/pytypenames.h b/sources/shiboken6/generator/shiboken/pytypenames.h
index bd5994cf4..7dd5f8aee 100644
--- a/sources/shiboken6/generator/shiboken/pytypenames.h
+++ b/sources/shiboken6/generator/shiboken/pytypenames.h
@@ -35,6 +35,14 @@ static inline QString pyBoolT() { return QStringLiteral("PyBool"); }
 static inline QString pyFloatT() { return QStringLiteral("PyFloat"); }
 static inline QString pyIntT() { return QStringLiteral("PyInt"); }
 static inline QString pyLongT() { return QStringLiteral("PyLong"); }
+static inline QString pyObjectT() { return QStringLiteral("object"); }
+static inline QString pyStrT() { return QStringLiteral("str"); }
+
+static inline QString cPyBufferT() { return QStringLiteral("PyBuffer"); }
+static inline QString cPyListT() { return QStringLiteral("PyList"); }
+static inline QString cPyObjectT() { return QStringLiteral("PyObject"); }
+static inline QString cPySequenceT() { return QStringLiteral("PySequence"); }
+static inline QString cPyTypeObjectT() { return QStringLiteral("PyTypeObject"); }
 
 static inline QString sbkCharT() { return QStringLiteral("SbkChar"); }
 
diff --git a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
index 201576675..3f517ddee 100644
--- a/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/shibokengenerator.cpp
@@ -748,7 +748,7 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntry *type)
                 //break;
             case ContainerTypeEntry::PairContainer:
                 //baseName = "PyTuple";
-                baseName = QLatin1String("PySequence");
+                baseName = cPySequenceT();
                 break;
             case ContainerTypeEntry::SetContainer:
                 baseName = QLatin1String("PySet");
@@ -763,7 +763,7 @@ QString ShibokenGenerator::cpythonBaseName(const TypeEntry *type)
                 Q_ASSERT(false);
         }
     } else {
-        baseName = QLatin1String("PyObject");
+        baseName = cPyObjectT();
     }
     return baseName.replace(QLatin1String("::"), QLatin1String("_"));
 }
@@ -1128,16 +1128,16 @@ ShibokenGenerator::CPythonCheckFunctionResult
 {
     // PYSIDE-795: We abuse PySequence for iterables.
     // This part handles the overrides in the XML files.
-    if (type == QLatin1String("PySequence"))
+    if (type == cPySequenceT())
         return {QLatin1String("Shiboken::String::checkIterable"), {}};
 
-    if (type == QLatin1String("PyTypeObject"))
+    if (type == cPyTypeObjectT())
         return {QLatin1String("PyType_Check"), {}};
 
-    if (type == QLatin1String("PyBuffer"))
+    if (type == cPyBufferT())
         return {QLatin1String("Shiboken::Buffer::checkType"), {}};
 
-    if (type == QLatin1String("str"))
+    if (type == pyStrT())
         return {QLatin1String("Shiboken::String::check"), {}};
 
     CPythonCheckFunctionResult result;
@@ -1995,7 +1995,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
             case TypeSystemCheckFunction:
                 conversion = cpythonCheckFunction(conversionType);
                 if (conversionType.typeEntry()->isPrimitive()
-                    && (conversionType.typeEntry()->name() == QLatin1String("PyObject")
+                    && (conversionType.typeEntry()->name() == cPyObjectT()
                         || !conversion.endsWith(QLatin1Char(' ')))) {
                     conversion += u'(';
                     break;