Fix some clang-tidy warnings in shiboken

- 'else if' after return/break/continue
- Use const ref for complex arguments passed by value where possible
- Fix 'if (foo) delete foo' to 'delete foo'
- Use container.isEmpty() instead of container.size() in checks
- Use ' = default' for trivial constructors/destructors
- Use range based for where possible
- Complete constructor initializer lists
- Fix invocations of static methods
- Replace some reinterpret_cast by static_cast
- Remove unused variables/fields
- Use initializer lists for return types

Change-Id: Id5b44a2f9d429f66ef069d532a1cd31df796d38e
Reviewed-by: Christian Tismer <tismer@stackless.com>

7 files changed, 66 insertions, 75 deletions

diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
index a9556fa4c..98c16bdd9 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
@@ -3117,8 +3117,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
                 bool hasConversionRule = !func->conversionRule(TypeSystem::NativeCode, arg->argumentIndex() + 1).isEmpty();
                 if (argsClear && !defValModified && !hasConversionRule)
                     continue;
-                else
-                    argsClear = false;
+                argsClear = false;
                 otherArgsModified |= defValModified || hasConversionRule || func->argumentRemoved(i + 1);
                 if (hasConversionRule)
                     otherArgs.prepend(arg->name() + QLatin1String(CONV_RULE_OUT_VAR_SUFFIX));
@@ -3409,7 +3408,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
             s << "reinterpret_cast<SbkObject*>(" PYTHON_SELF_VAR "), \"";
             QString varName = arg_mod.referenceCounts.constFirst().varName;
             if (varName.isEmpty())
-                varName = func->minimalSignature() + QString().number(arg_mod.index);
+                varName = func->minimalSignature() + QString::number(arg_mod.index);
 
             s << varName << "\", " << pyArgName
               << (refCount.action == ReferenceCount::Add ? ", true" : "")
@@ -3531,7 +3530,7 @@ void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const TypeEn
 
     const FlagsTypeEntry* flags = 0;
     if (enumType->isFlags())
-        flags = reinterpret_cast<const FlagsTypeEntry*>(enumType);
+        flags = static_cast<const FlagsTypeEntry*>(enumType);
 
     s << INDENT << "// Register converter for " << enumFlagName << " '" << enumType->qualifiedCppName() << "'." << endl;
     s << INDENT << '{' << endl;
@@ -3575,7 +3574,7 @@ void CppGenerator::writeEnumConverterInitialization(QTextStream& s, const TypeEn
     s << INDENT << '}' << endl;
 
     if (!flags)
-        writeEnumConverterInitialization(s, reinterpret_cast<const EnumTypeEntry*>(enumType)->flags());
+        writeEnumConverterInitialization(s, static_cast<const EnumTypeEntry*>(enumType)->flags());
 }
 
 void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const AbstractMetaType* type)
@@ -3656,10 +3655,7 @@ bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass* metaClass)
     }
 
     const ComplexTypeEntry* baseType = metaClass->typeEntry()->baseContainerType();
-    if (baseType && baseType->isContainer())
-        return true;
-
-    return false;
+    return baseType && baseType->isContainer();
 }
 
 bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass* metaClass)
@@ -3964,7 +3960,6 @@ void CppGenerator::writeTypeAsMappingDefinition(QTextStream& s, const AbstractMe
         funcs.insert(QLatin1String("__msetitem__"), QString());
     }
 
-    QString baseName = cpythonBaseName(metaClass);
     for (auto it = m_mpFuncs.cbegin(), end = m_mpFuncs.cend(); it != end; ++it) {
         const QString &mpName = it.key();
         if (funcs[mpName].isEmpty())
@@ -4354,7 +4349,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
     s << '}' << endl << endl;
 }
 
-void CppGenerator::writeMethodDefinitionEntry(QTextStream& s, const AbstractMetaFunctionList overloads)
+void CppGenerator::writeMethodDefinitionEntry(QTextStream& s, const AbstractMetaFunctionList &overloads)
 {
     Q_ASSERT(!overloads.isEmpty());
     OverloadData overloadData(overloads, this);
@@ -4378,7 +4373,7 @@ void CppGenerator::writeMethodDefinitionEntry(QTextStream& s, const AbstractMeta
         s << "|METH_STATIC";
 }
 
-void CppGenerator::writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList overloads)
+void CppGenerator::writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList &overloads)
 {
     Q_ASSERT(!overloads.isEmpty());
     const AbstractMetaFunction* func = overloads.constFirst();
@@ -4679,7 +4674,7 @@ void CppGenerator::writeFlagsNumberMethodsDefinition(QTextStream& s, const Abstr
 }
 
 void CppGenerator::writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
-                                            QString pyOpName, QString cppOpName)
+                                            const QString &pyOpName, const QString &cppOpName)
 {
     FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags();
     Q_ASSERT(flagsEntry);
@@ -4704,7 +4699,8 @@ void CppGenerator::writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEn
 }
 
 void CppGenerator::writeFlagsUnaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
-                                           QString pyOpName, QString cppOpName, bool boolResult)
+                                           const QString &pyOpName,
+                                           const QString &cppOpName, bool boolResult)
 {
     FlagsTypeEntry* flagsEntry = cppEnum->typeEntry()->flags();
     Q_ASSERT(flagsEntry);
@@ -5326,7 +5322,7 @@ bool CppGenerator::finishGeneration()
     }
 
     TypeDatabase* typeDb = TypeDatabase::instance();
-    TypeSystemTypeEntry* moduleEntry = reinterpret_cast<TypeSystemTypeEntry*>(typeDb->findType(packageName()));
+    TypeSystemTypeEntry* moduleEntry = static_cast<TypeSystemTypeEntry*>(typeDb->findType(packageName()));
 
     //Extra includes
     s << endl << "// Extra includes" << endl;
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.h b/sources/shiboken2/generator/shiboken2/cppgenerator.h
index 1b59bcda7..49a1e1835 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.h
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.h
@@ -234,8 +234,8 @@ private:
     void writeClassDefinition(QTextStream &s,
                               const AbstractMetaClass *metaClass,
                               GeneratorContext &classContext);
-    void writeMethodDefinitionEntry(QTextStream& s, const AbstractMetaFunctionList overloads);
-    void writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList overloads);
+    void writeMethodDefinitionEntry(QTextStream& s, const AbstractMetaFunctionList &overloads);
+    void writeMethodDefinition(QTextStream& s, const AbstractMetaFunctionList &overloads);
     void writeSignatureInfo(QTextStream &s, const AbstractMetaFunctionList &overloads);
     /// Writes the implementation of all methods part of python sequence protocol
     void writeSequenceMethods(QTextStream &s,
@@ -275,9 +275,10 @@ private:
     void writeFlagsNonZero(QTextStream& s, const AbstractMetaEnum* cppEnum);
     void writeFlagsNumberMethodsDefinition(QTextStream& s, const AbstractMetaEnum* cppEnum);
     void writeFlagsBinaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
-                                  QString pyOpName, QString cppOpName);
+                                  const QString &pyOpName, const QString &cppOpName);
     void writeFlagsUnaryOperator(QTextStream& s, const AbstractMetaEnum* cppEnum,
-                                 QString pyOpName, QString cppOpName, bool boolResult = false);
+                                 const QString &pyOpName, const QString &cppOpName,
+                                 bool boolResult = false);
 
     /// Writes the function that registers the multiple inheritance information for the classes that need it.
     void writeMultipleInheritanceInitializerFunction(QTextStream& s, const AbstractMetaClass* metaClass);
diff --git a/sources/shiboken2/generator/shiboken2/headergenerator.cpp b/sources/shiboken2/generator/shiboken2/headergenerator.cpp
index 509169681..27463490a 100644
--- a/sources/shiboken2/generator/shiboken2/headergenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/headergenerator.cpp
@@ -49,11 +49,10 @@ QString HeaderGenerator::fileNameForContext(GeneratorContext &context) const
         QString fileNameBase = metaClass->qualifiedCppName().toLower();
         fileNameBase.replace(QLatin1String("::"), QLatin1String("_"));
         return fileNameBase + fileNameSuffix();
-    } else {
-        const AbstractMetaType *smartPointerType = context.preciseType();
-        QString fileNameBase = getFileNameBaseForSmartPointer(smartPointerType, metaClass);
-        return fileNameBase + fileNameSuffix();
     }
+    const AbstractMetaType *smartPointerType = context.preciseType();
+    QString fileNameBase = getFileNameBaseForSmartPointer(smartPointerType, metaClass);
+    return fileNameBase + fileNameSuffix();
 }
 
 void HeaderGenerator::writeCopyCtor(QTextStream& s, const AbstractMetaClass* metaClass) const
@@ -173,7 +172,7 @@ void HeaderGenerator::generateClass(QTextStream &s, GeneratorContext &classConte
             s << INDENT << "void* qt_metacast(const char* _clname) override;" << endl;
         }
 
-        if (m_inheritedOverloads.size()) {
+        if (!m_inheritedOverloads.isEmpty()) {
             s << INDENT << "// Inherited overloads, because the using keyword sux" << endl;
             writeInheritedOverloads(s);
             m_inheritedOverloads.clear();
@@ -230,7 +229,7 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
             QString argName = arg->name();
             const TypeEntry* enumTypeEntry = 0;
             if (arg->type()->isFlags())
-                enumTypeEntry = reinterpret_cast<const FlagsTypeEntry*>(arg->type()->typeEntry())->originator();
+                enumTypeEntry = static_cast<const FlagsTypeEntry*>(arg->type()->typeEntry())->originator();
             else if (arg->type()->isEnum())
                 enumTypeEntry = arg->type()->typeEntry();
             if (enumTypeEntry)
@@ -300,7 +299,7 @@ void HeaderGenerator::writeTypeIndexDefineLine(QTextStream& s, const TypeEntry*
     const int typeIndex = typeEntry->sbkIndex();
     _writeTypeIndexDefineLine(s, getTypeIndexVariableName(typeEntry), typeIndex);
     if (typeEntry->isComplex()) {
-        const ComplexTypeEntry* cType = reinterpret_cast<const ComplexTypeEntry*>(typeEntry);
+        const ComplexTypeEntry* cType = static_cast<const ComplexTypeEntry*>(typeEntry);
         if (cType->baseContainerType()) {
             const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(classes(), cType);
             if (metaClass->templateBaseClass())
@@ -308,7 +307,7 @@ void HeaderGenerator::writeTypeIndexDefineLine(QTextStream& s, const TypeEntry*
         }
     }
     if (typeEntry->isEnum()) {
-        const EnumTypeEntry* ete = reinterpret_cast<const EnumTypeEntry*>(typeEntry);
+        const EnumTypeEntry* ete = static_cast<const EnumTypeEntry*>(typeEntry);
         if (ete->flags())
             writeTypeIndexDefineLine(s, ete->flags());
     }
@@ -580,7 +579,7 @@ void HeaderGenerator::writeInheritedOverloads(QTextStream& s)
             QString argName = arg->name();
             const TypeEntry* enumTypeEntry = 0;
             if (arg->type()->isFlags())
-                enumTypeEntry = reinterpret_cast<const FlagsTypeEntry*>(arg->type()->typeEntry())->originator();
+                enumTypeEntry = static_cast<const FlagsTypeEntry*>(arg->type()->typeEntry())->originator();
             else if (arg->type()->isEnum())
                 enumTypeEntry = arg->type()->typeEntry();
             if (enumTypeEntry)
diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.cpp b/sources/shiboken2/generator/shiboken2/overloaddata.cpp
index 73198ba12..333ee00c6 100644
--- a/sources/shiboken2/generator/shiboken2/overloaddata.cpp
+++ b/sources/shiboken2/generator/shiboken2/overloaddata.cpp
@@ -94,8 +94,6 @@ static bool typesAreEqual(const AbstractMetaType* typeA, const AbstractMetaType*
  */
 struct OverloadSortData
 {
-    OverloadSortData() : counter(0) {}
-
     /**
      * Adds a typeName into the type map without associating it with
      * a OverloadData. This is done to express type dependencies that could
@@ -121,7 +119,7 @@ struct OverloadSortData
 
     int lastProcessedItemId() { return counter - 1; }
 
-    int counter;
+    int counter = 0;
     QHash<QString, int> map;                // typeName -> id
     QHash<int, OverloadData*> reverseMap;   // id -> OverloadData;
 };
@@ -499,7 +497,8 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib
 OverloadData::OverloadData(OverloadData* headOverloadData, const AbstractMetaFunction* func,
                                  const AbstractMetaType* argType, int argPos)
     : m_minArgs(256), m_maxArgs(0), m_argPos(argPos), m_argType(argType),
-      m_headOverloadData(headOverloadData), m_previousOverloadData(0)
+      m_headOverloadData(headOverloadData), m_previousOverloadData(nullptr),
+      m_generator(nullptr)
 {
     if (func)
         this->addOverload(func);
@@ -808,8 +807,7 @@ QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList&
 {
     int minArgs = 10000;
     int maxArgs = 0;
-    for (int i = 0; i < overloads.size(); i++) {
-        const AbstractMetaFunction* func = overloads[i];
+    for (const AbstractMetaFunction *func : overloads) {
         int origNumArgs = func->arguments().size();
         int removed = numberOfRemovedArguments(func);
         int numArgs = origNumArgs - removed;
@@ -825,7 +823,7 @@ QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList&
                 minArgs = fixedArgIndex;
         }
     }
-    return QPair<int, int>(minArgs, maxArgs);
+    return {minArgs, maxArgs};
 }
 
 bool OverloadData::isSingleArgument(const AbstractMetaFunctionList& overloads)
@@ -840,7 +838,7 @@ bool OverloadData::isSingleArgument(const AbstractMetaFunctionList& overloads)
     return singleArgument;
 }
 
-void OverloadData::dumpGraph(QString filename) const
+void OverloadData::dumpGraph(const QString &filename) const
 {
     QFile file(filename);
     if (file.open(QFile::WriteOnly)) {
diff --git a/sources/shiboken2/generator/shiboken2/overloaddata.h b/sources/shiboken2/generator/shiboken2/overloaddata.h
index 435c19aa2..4759ca9c3 100644
--- a/sources/shiboken2/generator/shiboken2/overloaddata.h
+++ b/sources/shiboken2/generator/shiboken2/overloaddata.h
@@ -114,7 +114,7 @@ public:
     /// Returns true if all overloads have no more than one argument.
     static bool isSingleArgument(const AbstractMetaFunctionList& overloads);
 
-    void dumpGraph(QString filename) const;
+    void dumpGraph(const QString &filename) const;
     QString dumpGraph() const;
 
     bool hasArgumentTypeReplace() const;
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
index 1d3f52ba4..16f5fafd3 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
@@ -101,7 +101,7 @@ static QString resolveScopePrefix(const AbstractMetaEnum *metaEnum,
     return resolveScopePrefix(parts, value);
 }
 
-ShibokenGenerator::ShibokenGenerator() : Generator()
+ShibokenGenerator::ShibokenGenerator()
 {
     if (m_pythonPrimitiveTypeName.isEmpty())
         ShibokenGenerator::initPrimitiveTypesCorrespondences();
@@ -124,11 +124,7 @@ ShibokenGenerator::ShibokenGenerator() : Generator()
     m_typeSystemConvRegEx[TypeSystemToCppFunction]         = QRegularExpression(QLatin1String(CONVERTTOCPP_REGEX));
 }
 
-ShibokenGenerator::~ShibokenGenerator()
-{
-    // TODO-CONVERTER: it must be caching types that were not created here.
-    //qDeleteAll(m_metaTypeFromStringCache.values());
-}
+ShibokenGenerator::~ShibokenGenerator() = default;
 
 void ShibokenGenerator::clearTpFuncs()
 {
@@ -278,7 +274,7 @@ bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass* metaCl
             for (const AbstractMetaFunction *func : funcs) {
                 if (!func->isProtected() || func->isSignal() || func->isModifiedRemoved())
                     continue;
-                else if (func->isOperatorOverload())
+                if (func->isOperatorOverload())
                     protectedOperators++;
                 else
                     protectedFunctions++;
@@ -333,9 +329,8 @@ QString ShibokenGenerator::wrapperName(const AbstractMetaClass* metaClass) const
 
         result += QLatin1String("Wrapper");
         return result;
-    } else {
-        return metaClass->qualifiedCppName();
     }
+    return metaClass->qualifiedCppName();
 }
 
 QString ShibokenGenerator::wrapperName(const AbstractMetaType *metaType) const
@@ -435,7 +430,8 @@ QString ShibokenGenerator::cpythonSetterFunctionName(const AbstractMetaField* me
     return QStringLiteral("%1_set_%2").arg(cpythonBaseName(metaField->enclosingClass()), metaField->name());
 }
 
-static QString cpythonEnumFlagsName(QString moduleName, QString qualifiedCppName)
+static QString cpythonEnumFlagsName(const QString &moduleName,
+                                    const QString &qualifiedCppName)
 {
     QString result = QStringLiteral("Sbk%1_%2").arg(moduleName, qualifiedCppName);
     result.replace(QLatin1String("::"), QLatin1String("_"));
@@ -617,12 +613,14 @@ QString ShibokenGenerator::cpythonSpecialCastFunctionName(const AbstractMetaClas
     return cpythonBaseName(metaClass->typeEntry()) + QLatin1String("SpecialCastFunction");
 }
 
-QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass* metaClass, QString argName)
+QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaClass* metaClass,
+                                              const QString &argName)
 {
     return cpythonWrapperCPtr(metaClass->typeEntry(), argName);
 }
 
-QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaType *metaType, QString argName)
+QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaType *metaType,
+                                              const QString &argName)
 {
     if (!ShibokenGenerator::isWrapperType(metaType->typeEntry()))
         return QString();
@@ -631,7 +629,8 @@ QString ShibokenGenerator::cpythonWrapperCPtr(const AbstractMetaType *metaType,
         + QLatin1String(", reinterpret_cast<SbkObject *>(") + argName + QLatin1String(")))");
 }
 
-QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry* type, QString argName)
+QString ShibokenGenerator::cpythonWrapperCPtr(const TypeEntry* type,
+                                              const QString &argName)
 {
     if (!ShibokenGenerator::isWrapperType(type))
         return QString();
@@ -927,7 +926,7 @@ QString ShibokenGenerator::pythonPrimitiveTypeName(const PrimitiveTypeEntry* typ
     return pythonPrimitiveTypeName(type->name());
 }
 
-QString ShibokenGenerator::pythonOperatorFunctionName(QString cppOpFuncName)
+QString ShibokenGenerator::pythonOperatorFunctionName(const QString &cppOpFuncName)
 {
     QString value = m_pythonOperators.value(cppOpFuncName);
     if (value.isEmpty())
@@ -955,7 +954,7 @@ QString ShibokenGenerator::pythonOperatorFunctionName(const AbstractMetaFunction
     return op;
 }
 
-QString ShibokenGenerator::pythonRichCompareOperatorId(QString cppOpFuncName)
+QString ShibokenGenerator::pythonRichCompareOperatorId(const QString &cppOpFuncName)
 {
     return QLatin1String("Py_") + m_pythonOperators.value(cppOpFuncName).toUpper();
 }
@@ -965,7 +964,7 @@ QString ShibokenGenerator::pythonRichCompareOperatorId(const AbstractMetaFunctio
     return pythonRichCompareOperatorId(func->originalName());
 }
 
-bool ShibokenGenerator::isNumber(QString cpythonApiName)
+bool ShibokenGenerator::isNumber(const QString &cpythonApiName)
 {
     return cpythonApiName == QLatin1String("PyInt")
             || cpythonApiName == QLatin1String("PyFloat")
@@ -1128,7 +1127,8 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
         if (isVoidPointer(metaType))
             return QLatin1String("PyObject_Check");
         return cpythonCheckFunction(metaType->typeEntry(), genericNumberType);
-    } else if (metaType->typeEntry()->isContainer()) {
+    }
+    if (metaType->typeEntry()->isContainer()) {
         QString typeCheck = QLatin1String("Shiboken::Conversions::");
         ContainerTypeEntry::Type type =
             static_cast<const ContainerTypeEntry *>(metaType->typeEntry())->type();
@@ -1158,8 +1158,8 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
             const AbstractMetaType* firstType = metaType->instantiations().constFirst();
             const AbstractMetaType* secondType = metaType->instantiations().constLast();
             if (isPointerToWrapperType(firstType) && isPointerToWrapperType(secondType)) {
-                typeCheck += QString::fromLatin1("check%1Types(%2, %3, ").arg(pyType)
-                                .arg(cpythonTypeNameExt(firstType), cpythonTypeNameExt(secondType));
+                typeCheck += QString::fromLatin1("check%1Types(%2, %3, ")
+                             .arg(pyType, cpythonTypeNameExt(firstType), cpythonTypeNameExt(secondType));
             } else {
                 typeCheck += QString::fromLatin1("convertible%1Types(%2, %3, %4, %5, ")
                                 .arg(pyType, converterObject(firstType),
@@ -1186,7 +1186,7 @@ QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry* type, bool gene
 
     if (type->isEnum() || type->isFlags() || isWrapperType(type))
         return QString::fromLatin1("SbkObject_TypeCheck(%1, ").arg(cpythonTypeNameExt(type));
-    else if (isCppPrimitive(type)) {
+    if (isCppPrimitive(type)) {
         return pythonPrimitiveTypeName(static_cast<const PrimitiveTypeEntry *>(type))
                                        + QLatin1String("_Check");
     }
@@ -1418,13 +1418,12 @@ QString ShibokenGenerator::functionReturnType(const AbstractMetaFunction* func,
     QString modifiedReturnType = QString(func->typeReplaced(0));
     if (!modifiedReturnType.isNull() && !(options & OriginalTypeDescription))
         return modifiedReturnType;
-    else
-        return translateType(func->type(), func->implementingClass(), options);
+    return translateType(func->type(), func->implementingClass(), options);
 }
 
 QString ShibokenGenerator::functionSignature(const AbstractMetaFunction *func,
-                                             QString prepend,
-                                             QString append,
+                                             const QString &prepend,
+                                             const QString &append,
                                              Options options,
                                              int /* argCount */) const
 {
@@ -1985,7 +1984,7 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
         const QRegularExpressionMatch match = rit.next();
         const QStringList list = match.capturedTexts();
         QString conversionString = list.constFirst();
-        QString conversionTypeName = list.constLast();
+        const QString &conversionTypeName = list.constLast();
         QString message;
         const AbstractMetaType *conversionType = buildAbstractMetaTypeFromString(conversionTypeName, &message);
         if (!conversionType) {
@@ -2182,9 +2181,7 @@ bool ShibokenGenerator::classNeedsSetattroFunction(const AbstractMetaClass *meta
 {
     if (!metaClass)
         return false;
-    if (metaClass->typeEntry()->isSmartPointer())
-        return true;
-    return false;
+    return metaClass->typeEntry()->isSmartPointer();
 }
 
 AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStaticMethods(const AbstractMetaClass* metaClass)
@@ -2264,7 +2261,7 @@ bool ShibokenGenerator::isCopyable(const AbstractMetaClass *metaClass)
 {
     if (metaClass->isNamespace() || isObjectType(metaClass))
         return false;
-    else if (metaClass->typeEntry()->copyable() == ComplexTypeEntry::Unknown)
+    if (metaClass->typeEntry()->copyable() == ComplexTypeEntry::Unknown)
         return metaClass->hasCloneOperator();
 
     return metaClass->typeEntry()->copyable() == ComplexTypeEntry::CopyableSet;
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.h b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
index d06803e82..ed8f1bbfb 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.h
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
@@ -239,8 +239,8 @@ public:
      *   \param arg_count the number of function arguments
      */
     QString functionSignature(const AbstractMetaFunction* func,
-                              QString prepend = QString(),
-                              QString append = QString(),
+                              const QString &prepend = QString(),
+                              const QString &append = QString(),
                               Options options = NoOption,
                               int arg_count = -1) const;
 
@@ -292,16 +292,16 @@ public:
     static QString pythonPrimitiveTypeName(const QString& cppTypeName);
     static QString pythonPrimitiveTypeName(const PrimitiveTypeEntry* type);
 
-    static QString pythonOperatorFunctionName(QString cppOpFuncName);
+    static QString pythonOperatorFunctionName(const QString &cppOpFuncName);
     static QString pythonOperatorFunctionName(const AbstractMetaFunction* func);
-    static QString pythonRichCompareOperatorId(QString cppOpFuncName);
+    static QString pythonRichCompareOperatorId(const QString &cppOpFuncName);
     static QString pythonRichCompareOperatorId(const AbstractMetaFunction* func);
 
     static QString fixedCppTypeName(const CustomConversion::TargetToNativeConversion* toNative);
     static QString fixedCppTypeName(const AbstractMetaType* type);
     static QString fixedCppTypeName(const TypeEntry* type, QString typeName = QString());
 
-    static bool isNumber(QString cpythonApiName);
+    static bool isNumber(const QString &cpythonApiName);
     static bool isNumber(const TypeEntry* type);
     static bool isNumber(const AbstractMetaType* type);
     static bool isPyInt(const TypeEntry* type);
@@ -389,9 +389,10 @@ public:
     QString cpythonSetattroFunctionName(const AbstractMetaClass* metaClass);
     QString cpythonGetterFunctionName(const AbstractMetaField* metaField);
     QString cpythonSetterFunctionName(const AbstractMetaField* metaField);
-    QString cpythonWrapperCPtr(const AbstractMetaClass* metaClass, QString argName = QLatin1String(PYTHON_SELF_VAR));
-    QString cpythonWrapperCPtr(const AbstractMetaType *metaType, QString argName);
-    QString cpythonWrapperCPtr(const TypeEntry* type, QString argName);
+    QString cpythonWrapperCPtr(const AbstractMetaClass* metaClass,
+                               const QString &argName = QLatin1String(PYTHON_SELF_VAR));
+    QString cpythonWrapperCPtr(const AbstractMetaType *metaType, const QString &argName);
+    QString cpythonWrapperCPtr(const TypeEntry* type, const QString &argName);
 
     /// Guesses the scope to where belongs an argument's default value.
     QString guessScopeForDefaultValue(const AbstractMetaFunction *func,
@@ -468,7 +469,6 @@ protected:
     // verify whether the class is copyable
     bool isCopyable(const AbstractMetaClass* metaClass);
 
-    bool m_native_jump_table;
     static QHash<QString, QString> m_pythonPrimitiveTypeName;
     static QHash<QString, QString> m_pythonOperators;
     static QHash<QString, QString> m_formatUnits;