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>

24 files changed, 206 insertions, 256 deletions

diff --git a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
index 2e06a5346..4aa5d72dd 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetabuilder.cpp
@@ -241,7 +241,7 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
     }
 }
 
-AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(ArgumentModelItem argument)
+AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(const ArgumentModelItem &argument)
 {
     AbstractMetaClass* returned = 0;
     AbstractMetaType *type = translateType(argument->type());
@@ -256,7 +256,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::argumentToClass(ArgumentModelItem
 /**
  * Checks the argument of a hash function and flags the type if it is a complex type
  */
-void AbstractMetaBuilderPrivate::registerHashFunction(FunctionModelItem function_item)
+void AbstractMetaBuilderPrivate::registerHashFunction(const FunctionModelItem &function_item)
 {
     ArgumentList arguments = function_item->arguments();
     if (arguments.size() == 1) {
@@ -269,12 +269,12 @@ void AbstractMetaBuilderPrivate::registerHashFunction(FunctionModelItem function
  * Check if a class has a debug stream operator that can be used as toString
  */
 
-void AbstractMetaBuilderPrivate::registerToStringCapability(FunctionModelItem function_item)
+void AbstractMetaBuilderPrivate::registerToStringCapability(const FunctionModelItem &function_item)
 {
     ArgumentList arguments = function_item->arguments();
     if (arguments.size() == 2) {
         if (arguments.at(0)->type().toString() == QLatin1String("QDebug")) {
-            ArgumentModelItem arg = arguments.at(1);
+            const ArgumentModelItem &arg = arguments.at(1);
             if (AbstractMetaClass *cls = argumentToClass(arg)) {
                 if (arg->type().indirections() < 2)
                     cls->setToStringCapability(true);
@@ -283,7 +283,7 @@ void AbstractMetaBuilderPrivate::registerToStringCapability(FunctionModelItem fu
     }
 }
 
-void AbstractMetaBuilderPrivate::traverseOperatorFunction(FunctionModelItem item)
+void AbstractMetaBuilderPrivate::traverseOperatorFunction(const FunctionModelItem &item)
 {
     if (item->accessPolicy() != CodeModel::Public)
         return;
@@ -348,7 +348,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(FunctionModelItem item
             setupFunctionDefaults(metaFunction, baseoperandClass);
             baseoperandClass->addFunction(metaFunction);
             Q_ASSERT(!metaFunction->wasPrivate());
-        } else if (metaFunction) {
+        } else {
             delete metaFunction;
         }
 
@@ -356,7 +356,7 @@ void AbstractMetaBuilderPrivate::traverseOperatorFunction(FunctionModelItem item
     }
 }
 
-void AbstractMetaBuilderPrivate::traverseStreamOperator(FunctionModelItem item)
+void AbstractMetaBuilderPrivate::traverseStreamOperator(const FunctionModelItem &item)
 {
     ArgumentList arguments = item->arguments();
     if (arguments.size() == 2 && item->accessPolicy() == CodeModel::Public) {
@@ -404,7 +404,7 @@ void AbstractMetaBuilderPrivate::traverseStreamOperator(FunctionModelItem item)
                     funcClass->typeEntry()->addExtraInclude(streamClass->typeEntry()->include());
 
                 m_currentClass = oldCurrentClass;
-            } else if (streamFunction) {
+            } else {
                 delete streamFunction;
             }
 
@@ -848,7 +848,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
     return metaClass;
 }
 
-AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(EnumModelItem enumItem,
+AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(const EnumModelItem &enumItem,
                                                            AbstractMetaClass *enclosing,
                                                            const QSet<QString> &enumsDeclarations)
 {
@@ -857,7 +857,7 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(EnumModelItem enumIte
     TypeEntry* typeEntry = 0;
     if (enumItem->accessPolicy() == CodeModel::Private) {
         QStringList names = enumItem->qualifiedName();
-        QString enumName = names.constLast();
+        const QString &enumName = names.constLast();
         QString nspace;
         if (names.size() > 1)
             nspace = QStringList(names.mid(0, names.size() - 1)).join(colonColon());
@@ -1204,18 +1204,18 @@ void AbstractMetaBuilderPrivate::traverseNamespaceMembers(NamespaceModelItem ite
     m_currentClass = oldCurrentClass;
 }
 
-static inline QString fieldSignatureWithType(VariableModelItem field)
+static inline QString fieldSignatureWithType(const VariableModelItem &field)
 {
     return field->name() + QStringLiteral(" -> ") + field->type().toString();
 }
 
 static inline QString qualifiedFieldSignatureWithType(const QString &className,
-                                                      VariableModelItem field)
+                                                      const VariableModelItem &field)
 {
     return className + colonColon() + fieldSignatureWithType(field);
 }
 
-AbstractMetaField *AbstractMetaBuilderPrivate::traverseField(VariableModelItem field,
+AbstractMetaField *AbstractMetaBuilderPrivate::traverseField(const VariableModelItem &field,
                                                              const AbstractMetaClass *cls)
 {
     QString fieldName = field->name();
@@ -1272,7 +1272,7 @@ AbstractMetaField *AbstractMetaBuilderPrivate::traverseField(VariableModelItem f
     return metaField;
 }
 
-void AbstractMetaBuilderPrivate::traverseFields(ScopeModelItem scope_item,
+void AbstractMetaBuilderPrivate::traverseFields(const ScopeModelItem &scope_item,
                                                 AbstractMetaClass *metaClass)
 {
     const VariableList &variables = scope_item->variables();
@@ -1420,7 +1420,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
             }
         } else if (QPropertySpec* reset = metaClass->propertySpecForReset(metaFunction->name())) {
             // Property resetter must be in the form "void name()"
-            if ((!metaFunction->type()) && (metaFunction->arguments().size() == 0)) {
+            if ((!metaFunction->type()) && metaFunction->arguments().isEmpty()) {
                 *metaFunction += AbstractMetaAttributes::PropertyResetter;
                 metaFunction->setPropertySpec(reset);
             }
@@ -1629,7 +1629,7 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
     return true;
 }
 
-void AbstractMetaBuilderPrivate::traverseEnums(ScopeModelItem scopeItem,
+void AbstractMetaBuilderPrivate::traverseEnums(const ScopeModelItem &scopeItem,
                                                AbstractMetaClass *metaClass,
                                                const QStringList &enumsDeclarations)
 {
@@ -1718,10 +1718,9 @@ AbstractMetaFunction* AbstractMetaBuilderPrivate::traverseFunction(const AddedFu
             replacedExpression = metaFunction->replacedDefaultExpression(m_currentClass, i + 1);
 
         if (!replacedExpression.isEmpty()) {
-            QString expr = replacedExpression;
             if (!metaFunction->removedDefaultExpression(m_currentClass, i + 1)) {
-                metaArg->setDefaultValueExpression(expr);
-                metaArg->setOriginalDefaultValueExpression(expr);
+                metaArg->setDefaultValueExpression(replacedExpression);
+                metaArg->setOriginalDefaultValueExpression(replacedExpression);
 
                 if (metaArg->type()->isEnum() || metaArg->type()->isFlags())
                     m_enumDefaultArguments << QPair<AbstractMetaArgument*, AbstractMetaFunction*>(metaArg, metaFunction);
@@ -1778,7 +1777,7 @@ void AbstractMetaBuilderPrivate::fixArgumentNames(AbstractMetaFunction *func, co
     }
 }
 
-static QString functionSignature(FunctionModelItem functionItem)
+static QString functionSignature(const FunctionModelItem &functionItem)
 {
     QStringList args;
     const ArgumentList &arguments = functionItem->arguments();
@@ -1899,7 +1898,7 @@ bool AbstractMetaBuilderPrivate::setArrayArgumentType(AbstractMetaFunction *func
     return true;
 }
 
-AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModelItem functionItem)
+AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(const FunctionModelItem &functionItem)
 {
     if (functionItem->isDeleted() || !functionItem->templateParameters().isEmpty())
         return nullptr;
@@ -1924,18 +1923,16 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
     QString rejectReason;
     if (TypeDatabase::instance()->isFunctionRejected(className, functionName, &rejectReason)) {
         m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn + rejectReason, AbstractMetaBuilder::GenerationDisabled);
-        return 0;
-    } else {
-        const QString &signature = functionSignature(functionItem);
-        const bool rejected =
-            TypeDatabase::instance()->isFunctionRejected(className, signature,
-                                                         &rejectReason);
-        qCDebug(lcShiboken).nospace().noquote() << __FUNCTION__
-            << ": Checking rejection for signature \""
-            << signature << "\" for " << className << ": " << rejected;
-        if (rejected)
-            return nullptr;
+        return nullptr;
     }
+    const QString &signature = functionSignature(functionItem);
+    const bool rejected =
+        TypeDatabase::instance()->isFunctionRejected(className, signature, &rejectReason);
+    qCDebug(lcShiboken).nospace().noquote() << __FUNCTION__
+        << ": Checking rejection for signature \"" << signature << "\" for " << className
+        << ": " << rejected;
+    if (rejected)
+        return nullptr;
 
     if (functionItem->isFriend())
         return 0;
@@ -2027,7 +2024,7 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
     AbstractMetaArgumentList metaArguments;
 
     for (int i = 0; i < arguments.size(); ++i) {
-        ArgumentModelItem arg = arguments.at(i);
+        const ArgumentModelItem &arg = arguments.at(i);
 
         if (TypeDatabase::instance()->isArgumentTypeRejected(className, arg->type().toString(), &rejectReason)) {
             m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn + rejectReason, AbstractMetaBuilder::GenerationDisabled);
@@ -2074,7 +2071,7 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
 
     // Find the correct default values
     for (int i = 0, size = metaArguments.size(); i < size; ++i) {
-        ArgumentModelItem arg = arguments.at(i);
+        const ArgumentModelItem &arg = arguments.at(i);
         AbstractMetaArgument* metaArg = metaArguments.at(i);
 
         //use relace-default-expression for set default value
@@ -2228,7 +2225,7 @@ static const TypeEntry* findTypeEntryUsingContext(const AbstractMetaClass* metaC
 {
     const TypeEntry* type = 0;
     QStringList context = metaClass->qualifiedCppName().split(colonColon());
-    while(!type && (context.size() > 0) ) {
+    while (!type && !context.isEmpty()) {
         type = TypeDatabase::instance()->findType(context.join(colonColon()) + colonColon() + qualifiedName);
         context.removeLast();
     }
@@ -2451,7 +2448,7 @@ AbstractMetaType *AbstractMetaBuilderPrivate::translateTypeStatic(const TypeInfo
 
     const auto &templateArguments = typeInfo.instantiations();
     for (int t = 0, size = templateArguments.size(); t < size; ++t) {
-        TypeInfo ti = templateArguments.at(t);
+        const  TypeInfo &ti = templateArguments.at(t);
         AbstractMetaType *targType = translateTypeStatic(ti, currentClass, d, true, &errorMessage);
         if (!targType) {
             if (errorMessageIn)
@@ -2537,7 +2534,7 @@ qint64 AbstractMetaBuilderPrivate::findOutValueFromString(const QString &stringV
     return 0;
 }
 
-QString AbstractMetaBuilderPrivate::fixDefaultValue(ArgumentModelItem item,
+QString AbstractMetaBuilderPrivate::fixDefaultValue(const ArgumentModelItem &item,
                                                     AbstractMetaType *type,
                                                     AbstractMetaFunction *fnc,
                                                     AbstractMetaClass *implementingClass,
@@ -2892,13 +2889,9 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
 
         // if the instantiation has a function named the same as an existing
         // function we have shadowing so we need to skip it.
-        bool found = false;
-        for (int i = 0; i < funcs.size(); ++i) {
-            if (funcs.at(i)->name() == f->name()) {
-                found = true;
-                continue;
-            }
-        }
+        const bool found =
+            std::any_of(funcs.cbegin(), funcs.cend(),
+                        [f] (const AbstractMetaFunction *needle) { return needle->name() == f->name(); });
         if (found) {
             delete f;
             continue;
@@ -2943,9 +2936,9 @@ void AbstractMetaBuilderPrivate::parseQ_Property(AbstractMetaClass *metaClass,
                                                  const QStringList &declarations)
 {
     for (int i = 0; i < declarations.size(); ++i) {
-        QString p = declarations.at(i);
+        const QString &p = declarations.at(i);
 
-        QStringList l = p.split(QLatin1String(" "));
+        QStringList l = p.split(QLatin1Char(' '));
 
 
         QStringList qualifiedScopeName = currentScope()->qualifiedName();
diff --git a/sources/shiboken2/ApiExtractor/abstractmetabuilder_p.h b/sources/shiboken2/ApiExtractor/abstractmetabuilder_p.h
index 7d4e280bd..7f4d222a3 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetabuilder_p.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetabuilder_p.h
@@ -60,7 +60,7 @@ public:
 
     ScopeModelItem currentScope() const { return m_scopes.constLast(); }
 
-    AbstractMetaClass *argumentToClass(ArgumentModelItem);
+    AbstractMetaClass *argumentToClass(const ArgumentModelItem &);
 
     void addAbstractMetaClass(AbstractMetaClass *cls);
     AbstractMetaClass *traverseTypeDef(const FileModelItem &dom,
@@ -74,9 +74,9 @@ public:
     bool setupInheritance(AbstractMetaClass *metaClass);
     AbstractMetaClass *traverseNamespace(const FileModelItem &dom,
                                          const NamespaceModelItem &item);
-    AbstractMetaEnum *traverseEnum(EnumModelItem item, AbstractMetaClass *enclosing,
+    AbstractMetaEnum *traverseEnum(const EnumModelItem &item, AbstractMetaClass *enclosing,
                                    const QSet<QString> &enumsDeclarations);
-    void traverseEnums(ScopeModelItem item, AbstractMetaClass *parent,
+    void traverseEnums(const ScopeModelItem &item, AbstractMetaClass *parent,
                        const QStringList &enumsDeclarations);
     AbstractMetaFunctionList classFunctionList(const ScopeModelItem &scopeItem,
                                                bool *constructorRejected);
@@ -85,18 +85,18 @@ public:
                                                        bool *constructorRejected);
     void traverseFunctions(ScopeModelItem item, AbstractMetaClass *parent);
     void applyFunctionModifications(AbstractMetaFunction* func);
-    void traverseFields(ScopeModelItem item, AbstractMetaClass *parent);
-    void traverseStreamOperator(FunctionModelItem functionItem);
-    void traverseOperatorFunction(FunctionModelItem item);
+    void traverseFields(const ScopeModelItem &item, AbstractMetaClass *parent);
+    void traverseStreamOperator(const FunctionModelItem &functionItem);
+    void traverseOperatorFunction(const FunctionModelItem &item);
     AbstractMetaFunction* traverseFunction(const AddedFunction &addedFunc);
     AbstractMetaFunction* traverseFunction(const AddedFunction &addedFunc,
                                            AbstractMetaClass *metaClass);
-    AbstractMetaFunction *traverseFunction(FunctionModelItem function);
-    AbstractMetaField *traverseField(VariableModelItem field,
+    AbstractMetaFunction *traverseFunction(const FunctionModelItem &function);
+    AbstractMetaField *traverseField(const VariableModelItem &field,
                                      const AbstractMetaClass *cls);
     void checkFunctionModifications();
-    void registerHashFunction(FunctionModelItem functionItem);
-    void registerToStringCapability(FunctionModelItem functionItem);
+    void registerHashFunction(const FunctionModelItem &functionItem);
+    void registerToStringCapability(const FunctionModelItem &functionItem);
 
     /**
      *   A conversion operator function should not have its owner class as
@@ -118,7 +118,7 @@ public:
     void setupFunctionDefaults(AbstractMetaFunction *metaFunction,
                                AbstractMetaClass *metaClass);
 
-    QString fixDefaultValue(ArgumentModelItem item, AbstractMetaType *type,
+    QString fixDefaultValue(const ArgumentModelItem &item, AbstractMetaType *type,
                             AbstractMetaFunction *fnc, AbstractMetaClass *,
                             int argumentIndex);
     AbstractMetaType *translateType(const AddedFunction::TypeInfo &typeInfo);
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index 50ee849a2..de7182c71 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -543,18 +543,17 @@ QStringList AbstractMetaFunction::introspectionCompatibleSignatures(const QStrin
     if (arguments.size() == resolvedArguments.size()) {
         QString signature = name() + QLatin1Char('(') + resolvedArguments.join(QLatin1Char(',')) + QLatin1Char(')');
         return QStringList(TypeDatabase::normalizedSignature(signature));
-    } else {
-        QStringList returned;
-
-        AbstractMetaArgument *argument = arguments.at(resolvedArguments.size());
-        QStringList minimalTypeSignature = argument->type()->minimalSignature().split(QLatin1String("::"));
-        for (int i = 0; i < minimalTypeSignature.size(); ++i) {
-            returned += introspectionCompatibleSignatures(QStringList(resolvedArguments)
-                                                          << QStringList(minimalTypeSignature.mid(minimalTypeSignature.size() - i - 1)).join(QLatin1String("::")));
-        }
+    }
+    QStringList returned;
 
-        return returned;
+    AbstractMetaArgument *argument = arguments.at(resolvedArguments.size());
+    QStringList minimalTypeSignature = argument->type()->minimalSignature().split(QLatin1String("::"));
+    for (int i = 0; i < minimalTypeSignature.size(); ++i) {
+        returned += introspectionCompatibleSignatures(QStringList(resolvedArguments)
+                                                      << QStringList(minimalTypeSignature.mid(minimalTypeSignature.size() - i - 1)).join(QLatin1String("::")));
     }
+
+    return returned;
 }
 
 QString AbstractMetaFunction::signature() const
@@ -848,8 +847,9 @@ FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaC
     while (implementor) {
         mods += implementor->typeEntry()->functionModifications(minimalSignature());
         if ((implementor == implementor->baseClass()) ||
-            (implementor == implementingClass() && (mods.size() > 0)))
+            (implementor == implementingClass() && !mods.isEmpty())) {
                 break;
+        }
         const AbstractMetaClassList &interfaces = implementor->interfaces();
         for (const AbstractMetaClass *interface : interfaces)
             mods += this->modifications(interface);
@@ -912,14 +912,14 @@ bool AbstractMetaFunction::hasSignatureModifications() const
     return false;
 }
 
-bool AbstractMetaFunction::isConversionOperator(QString funcName)
+bool AbstractMetaFunction::isConversionOperator(const QString& funcName)
 {
     static const QRegularExpression opRegEx(QStringLiteral("^operator(?:\\s+(?:const|volatile))?\\s+(\\w+\\s*)&?$"));
     Q_ASSERT(opRegEx.isValid());
     return opRegEx.match(funcName).hasMatch();
 }
 
-bool AbstractMetaFunction::isOperatorOverload(QString funcName)
+bool AbstractMetaFunction::isOperatorOverload(const QString& funcName)
 {
     if (isConversionOperator(funcName))
         return true;
@@ -1762,7 +1762,7 @@ QDebug operator<<(QDebug d, const AbstractMetaEnum *ae)
 
 bool AbstractMetaClass::hasConstructors() const
 {
-    return queryFunctions(Constructors).size();
+    return !queryFunctions(Constructors).isEmpty();
 }
 
 bool AbstractMetaClass::hasCopyConstructor() const
@@ -2041,8 +2041,8 @@ void AbstractMetaClass::fixFunctions()
 {
     if (m_functionsFixed)
         return;
-    else
-        m_functionsFixed = true;
+
+    m_functionsFixed = true;
 
     AbstractMetaClass *superClass = baseClass();
     AbstractMetaFunctionList funcs = functions();
@@ -2085,8 +2085,7 @@ void AbstractMetaClass::fixFunctions()
             // we generally don't care about private functions, but we have to get the ones that are
             // virtual in case they override abstract functions.
             bool add = (sf->isNormal() || sf->isSignal() || sf->isEmptyFunction());
-            for (int fi = 0; fi < funcs.size(); ++fi) {
-                AbstractMetaFunction *f = funcs.at(fi);
+            for (AbstractMetaFunction *f : funcs) {
                 if (f->isRemovedFromAllLanguages(f->implementingClass()))
                     continue;
 
@@ -2153,7 +2152,8 @@ void AbstractMetaClass::fixFunctions()
                                     if (mod.isNonFinal()) {
                                         hasNonFinalModifier = true;
                                         break;
-                                    } else if (mod.isPrivate()) {
+                                    }
+                                    if (mod.isPrivate()) {
                                         isBaseImplPrivate = true;
                                         break;
                                     }
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.h b/sources/shiboken2/ApiExtractor/abstractmetalang.h
index de00ca486..d84a82af3 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.h
@@ -834,13 +834,13 @@ public:
         return m_explicit;
     }
 
-    static bool isConversionOperator(QString funcName);
+    static bool isConversionOperator(const QString& funcName);
     bool isConversionOperator() const
     {
         return isConversionOperator(originalName());
     }
 
-    static bool isOperatorOverload(QString funcName);
+    static bool isOperatorOverload(const QString& funcName);
     bool isOperatorOverload() const
     {
         return isOperatorOverload(originalName());
diff --git a/sources/shiboken2/ApiExtractor/apiextractor.cpp b/sources/shiboken2/ApiExtractor/apiextractor.cpp
index 171011cd4..80ffc3910 100644
--- a/sources/shiboken2/ApiExtractor/apiextractor.cpp
+++ b/sources/shiboken2/ApiExtractor/apiextractor.cpp
@@ -194,9 +194,9 @@ const AbstractMetaEnum* ApiExtractor::findAbstractMetaEnum(const TypeEntry* type
     if (!typeEntry)
         return 0;
     if (typeEntry->isFlags())
-        return findAbstractMetaEnum(reinterpret_cast<const FlagsTypeEntry*>(typeEntry));
+        return findAbstractMetaEnum(static_cast<const FlagsTypeEntry*>(typeEntry));
     if (typeEntry->isEnum())
-        return findAbstractMetaEnum(reinterpret_cast<const EnumTypeEntry*>(typeEntry));
+        return findAbstractMetaEnum(static_cast<const EnumTypeEntry*>(typeEntry));
     return 0;
 }
 
diff --git a/sources/shiboken2/ApiExtractor/clangparser/clangbuilder.cpp b/sources/shiboken2/ApiExtractor/clangparser/clangbuilder.cpp
index 633e5bac0..1623e6a6e 100644
--- a/sources/shiboken2/ApiExtractor/clangparser/clangbuilder.cpp
+++ b/sources/shiboken2/ApiExtractor/clangparser/clangbuilder.cpp
@@ -832,9 +832,8 @@ BaseVisitor::StartTokenResult Builder::startToken(const CXCursor &cursor)
                 d->m_currentFunction = d->createMemberFunction(cursor);
                 d->m_scopeStack.back()->addFunction(d->m_currentFunction);
                 break;
-            } else {
-                return Skip; // inline member functions outside class
             }
+            return Skip; // inline member functions outside class
         }
     }
         Q_FALLTHROUGH(); // fall through to free template function.
diff --git a/sources/shiboken2/ApiExtractor/clangparser/clangparser.cpp b/sources/shiboken2/ApiExtractor/clangparser/clangparser.cpp
index 301b4211e..9ce3234a5 100644
--- a/sources/shiboken2/ApiExtractor/clangparser/clangparser.cpp
+++ b/sources/shiboken2/ApiExtractor/clangparser/clangparser.cpp
@@ -166,7 +166,7 @@ static inline const char **byteArrayListToFlatArgV(const QByteArrayList &bl)
     return result;
 }
 
-static QByteArray msgCreateTranslationUnit(const QByteArrayList clangArgs, unsigned flags)
+static QByteArray msgCreateTranslationUnit(const QByteArrayList &clangArgs, unsigned flags)
 {
     QByteArray result = "clang_parseTranslationUnit2(0x";
     result += QByteArray::number(flags, 16);
diff --git a/sources/shiboken2/ApiExtractor/docparser.cpp b/sources/shiboken2/ApiExtractor/docparser.cpp
index 9305332ba..ce089c1f5 100644
--- a/sources/shiboken2/ApiExtractor/docparser.cpp
+++ b/sources/shiboken2/ApiExtractor/docparser.cpp
@@ -50,9 +50,7 @@ DocParser::DocParser()
 #endif
 }
 
-DocParser::~DocParser()
-{
-}
+DocParser::~DocParser() = default;
 
 QString DocParser::getDocumentation(QXmlQuery& xquery, const QString& query,
                                     const DocModificationList& mods) const
@@ -154,13 +152,16 @@ QString DocParser::msgCannotFindDocumentation(const QString &fileName,
 namespace
 {
 
-struct XslResources
+class XslResources
 {
-    xmlDocPtr xmlDoc;
-    xsltStylesheetPtr xslt;
-    xmlDocPtr xslResult;
+    Q_DISABLE_COPY(XslResources)
+
+public:
+    xmlDocPtr xmlDoc = nullptr;
+    xsltStylesheetPtr xslt = nullptr;
+    xmlDocPtr xslResult = nullptr;
 
-    XslResources() : xmlDoc(0), xslt(0), xslResult(0) {}
+    XslResources() = default;
 
     ~XslResources()
     {
diff --git a/sources/shiboken2/ApiExtractor/doxygenparser.cpp b/sources/shiboken2/ApiExtractor/doxygenparser.cpp
index dfdb37a47..7a0346cc6 100644
--- a/sources/shiboken2/ApiExtractor/doxygenparser.cpp
+++ b/sources/shiboken2/ApiExtractor/doxygenparser.cpp
@@ -35,23 +35,17 @@
 #include <QtCore/QFile>
 #include <QtCore/QDir>
 
-namespace
+static QString getSectionKindAttr(const AbstractMetaFunction *func)
 {
-
-QString getSectionKindAttr(const AbstractMetaFunction* func)
-{
-    if (func->isSignal()) {
+    if (func->isSignal())
         return QLatin1String("signal");
-    } else {
-        QString kind = func->isPublic() ? QLatin1String("public") : QLatin1String("protected");
-        if (func->isStatic())
-            kind += QLatin1String("-static");
-        else if (func->isSlot())
-            kind += QLatin1String("-slot");
-        return kind;
-    }
-}
-
+    QString kind = func->isPublic()
+        ? QLatin1String("public") : QLatin1String("protected");
+    if (func->isStatic())
+        kind += QLatin1String("-static");
+    else if (func->isSlot())
+        kind += QLatin1String("-slot");
+    return kind;
 }
 
 Documentation DoxygenParser::retrieveModuleDocumentation()
@@ -77,9 +71,9 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
     bool isProperty = false;
 
     QString doxyFilePath;
-    for (int i = 0; i < numPrefixes; ++i) {
+    for (const char *prefix : prefixes) {
         doxyFilePath = documentationDataDirectory() + QLatin1Char('/')
-                       + QLatin1String(prefixes[i]) + doxyFileSuffix;
+                       + QLatin1String(prefix) + doxyFileSuffix;
         if (QFile::exists(doxyFilePath))
             break;
         doxyFilePath.clear();
diff --git a/sources/shiboken2/ApiExtractor/include.cpp b/sources/shiboken2/ApiExtractor/include.cpp
index 963999b9d..d6a451992 100644
--- a/sources/shiboken2/ApiExtractor/include.cpp
+++ b/sources/shiboken2/ApiExtractor/include.cpp
@@ -36,10 +36,9 @@ QString Include::toString() const
 {
     if (m_type == IncludePath)
         return QLatin1String("#include <") + m_name + QLatin1Char('>');
-    else if (m_type == LocalPath)
+    if (m_type == LocalPath)
         return QLatin1String("#include \"") + m_name + QLatin1Char('"');
-    else
-        return QLatin1String("import ") + m_name + QLatin1Char(';');
+    return QLatin1String("import ") + m_name + QLatin1Char(';');
 }
 
 uint qHash(const Include& inc)
diff --git a/sources/shiboken2/ApiExtractor/parser/codemodel.cpp b/sources/shiboken2/ApiExtractor/parser/codemodel.cpp
index a560c0faf..2c8042dc0 100644
--- a/sources/shiboken2/ApiExtractor/parser/codemodel.cpp
+++ b/sources/shiboken2/ApiExtractor/parser/codemodel.cpp
@@ -449,9 +449,7 @@ _CodeModelItem::_CodeModelItem(CodeModel *model, const QString &name, int kind)
 {
 }
 
-_CodeModelItem::~_CodeModelItem()
-{
-}
+_CodeModelItem::~_CodeModelItem() = default;
 
 int _CodeModelItem::kind() const
 {
@@ -623,9 +621,7 @@ QDebug operator<<(QDebug d, const _CodeModelItem *t)
 #endif // !QT_NO_DEBUG_STREAM
 
 // ---------------------------------------------------------------------------
-_ClassModelItem::~_ClassModelItem()
-{
-}
+_ClassModelItem::~_ClassModelItem() = default;
 
 TemplateParameterList _ClassModelItem::templateParameters() const
 {
@@ -715,9 +711,7 @@ FunctionModelItem _ScopeModelItem::declaredFunction(FunctionModelItem item)
     return FunctionModelItem();
 }
 
-_ScopeModelItem::~_ScopeModelItem()
-{
-}
+_ScopeModelItem::~_ScopeModelItem() = default;
 
 void _ScopeModelItem::addEnumsDeclaration(const QString &enumsDeclaration)
 {
@@ -926,11 +920,9 @@ void _ArgumentModelItem::formatDebug(QDebug &d) const
 }
 #endif // !QT_NO_DEBUG_STREAM
 // ---------------------------------------------------------------------------
-_FunctionModelItem::~_FunctionModelItem()
-{
-}
+_FunctionModelItem::~_FunctionModelItem() = default;
 
-bool _FunctionModelItem::isSimilar(FunctionModelItem other) const
+bool _FunctionModelItem::isSimilar(const FunctionModelItem &other) const
 {
     if (name() != other->name())
         return false;
@@ -962,7 +954,7 @@ ArgumentList _FunctionModelItem::arguments() const
     return m_arguments;
 }
 
-void _FunctionModelItem::addArgument(ArgumentModelItem item)
+void _FunctionModelItem::addArgument(const ArgumentModelItem& item)
 {
     m_arguments.append(item);
 }
@@ -1182,9 +1174,7 @@ void _EnumModelItem::formatDebug(QDebug &d) const
 #endif // !QT_NO_DEBUG_STREAM
 
 // ---------------------------------------------------------------------------
-_EnumeratorModelItem::~_EnumeratorModelItem()
-{
-}
+_EnumeratorModelItem::~_EnumeratorModelItem() = default;
 
 QString _EnumeratorModelItem::stringValue() const
 {
@@ -1205,9 +1195,7 @@ void _EnumeratorModelItem::formatDebug(QDebug &d) const
 #endif // !QT_NO_DEBUG_STREAM
 
 // ---------------------------------------------------------------------------
-_TemplateParameterModelItem::~_TemplateParameterModelItem()
-{
-}
+_TemplateParameterModelItem::~_TemplateParameterModelItem() = default;
 
 TypeInfo _TemplateParameterModelItem::type() const
 {
@@ -1255,9 +1243,7 @@ CodeModel::AccessPolicy _MemberModelItem::accessPolicy() const
     return m_accessPolicy;
 }
 
-_MemberModelItem::~_MemberModelItem()
-{
-}
+_MemberModelItem::~_MemberModelItem() = default;
 
 void _MemberModelItem::setAccessPolicy(CodeModel::AccessPolicy accessPolicy)
 {
diff --git a/sources/shiboken2/ApiExtractor/parser/codemodel.h b/sources/shiboken2/ApiExtractor/parser/codemodel.h
index c61f640e1..a2cbcd6c0 100644
--- a/sources/shiboken2/ApiExtractor/parser/codemodel.h
+++ b/sources/shiboken2/ApiExtractor/parser/codemodel.h
@@ -568,7 +568,7 @@ public:
 
     ArgumentList arguments() const;
 
-    void addArgument(ArgumentModelItem item);
+    void addArgument(const ArgumentModelItem& item);
 
     CodeModel::FunctionType functionType() const;
     void setFunctionType(CodeModel::FunctionType functionType);
@@ -603,7 +603,7 @@ public:
     bool isVariadics() const;
     void setVariadics(bool isVariadics);
 
-    bool isSimilar(FunctionModelItem other) const;
+    bool isSimilar(const FunctionModelItem &other) const;
 
 #ifndef QT_NO_DEBUG_STREAM
     void formatDebug(QDebug &d) const override;
diff --git a/sources/shiboken2/ApiExtractor/typeparser.cpp b/sources/shiboken2/ApiExtractor/typeparser.cpp
index 0a60159ae..c440fb66d 100644
--- a/sources/shiboken2/ApiExtractor/typeparser.cpp
+++ b/sources/shiboken2/ApiExtractor/typeparser.cpp
@@ -56,7 +56,7 @@ public:
     };
 
     Scanner(const QString &s)
-            : m_pos(0), m_length(s.length()), m_chars(s.constData())
+            : m_pos(0), m_length(s.length()), m_tokenStart(-1), m_chars(s.constData())
     {
     }
 
diff --git a/sources/shiboken2/ApiExtractor/typesystem.cpp b/sources/shiboken2/ApiExtractor/typesystem.cpp
index 716b2b41b..78f8115e0 100644
--- a/sources/shiboken2/ApiExtractor/typesystem.cpp
+++ b/sources/shiboken2/ApiExtractor/typesystem.cpp
@@ -2630,10 +2630,7 @@ PrimitiveTypeEntry *PrimitiveTypeEntry::basicReferencedTypeEntry() const
         return 0;
 
     PrimitiveTypeEntry *baseReferencedTypeEntry = m_referencedTypeEntry->basicReferencedTypeEntry();
-    if (baseReferencedTypeEntry)
-        return baseReferencedTypeEntry;
-    else
-        return m_referencedTypeEntry;
+    return baseReferencedTypeEntry ? baseReferencedTypeEntry : m_referencedTypeEntry;
 }
 
 bool PrimitiveTypeEntry::preferredConversion() const
@@ -2734,10 +2731,7 @@ QString ContainerTypeEntry::qualifiedCppName() const
 QString EnumTypeEntry::targetLangQualifier() const
 {
     TypeEntry *te = TypeDatabase::instance()->findType(m_qualifier);
-    if (te)
-        return te->targetLangName();
-    else
-        return m_qualifier;
+    return te ? te->targetLangName() : m_qualifier;
 }
 
 QString EnumTypeEntry::qualifiedTargetLangName() const
@@ -2794,7 +2788,7 @@ QString fixCppTypeName(const QString &name)
 {
     if (name == QLatin1String("long long"))
         return QLatin1String("qint64");
-    else if (name == QLatin1String("unsigned long long"))
+    if (name == QLatin1String("unsigned long long"))
         return QLatin1String("quint64");
     return name;
 }
@@ -2815,11 +2809,9 @@ QString TemplateInstance::expandCode() const
         result += code;
         result += QLatin1String("\n// TEMPLATE - ") + m_name + QLatin1String(" - END");
         return result;
-    } else {
-        qCWarning(lcShiboken).noquote().nospace()
-            << "insert-template referring to non-existing template '" << m_name << '\'';
     }
-
+    qCWarning(lcShiboken).noquote().nospace()
+        << "insert-template referring to non-existing template '" << m_name << '\'';
     return QString();
 }
 
@@ -2835,10 +2827,7 @@ QString CodeSnipAbstract::code() const
 
 QString CodeSnipFragment::code() const
 {
-    if (m_instance)
-        return m_instance->expandCode();
-    else
-        return m_code;
+    return m_instance ? m_instance->expandCode() : m_code;
 }
 
 bool FunctionModification::setSignature(const QString &s, QString *errorMessage)
@@ -3176,10 +3165,9 @@ QString ArrayTypeEntry::targetLangName() const
 
 QString ArrayTypeEntry::targetLangApiName() const
 {
-    if (m_nestedType->isPrimitive())
-        return m_nestedType->targetLangApiName() + QLatin1String("Array");
-    else
-        return QLatin1String("jobjectArray");
+    return m_nestedType->isPrimitive()
+        ? m_nestedType->targetLangApiName() + QLatin1String("Array")
+        : QLatin1String("jobjectArray");
 }
 
 EnumTypeEntry::EnumTypeEntry(const QString &nspace, const QString &enumName,
diff --git a/sources/shiboken2/generator/generator.cpp b/sources/shiboken2/generator/generator.cpp
index 97c314275..63700f2c5 100644
--- a/sources/shiboken2/generator/generator.cpp
+++ b/sources/shiboken2/generator/generator.cpp
@@ -40,8 +40,9 @@
 #include <QDebug>
 #include <typedatabase.h>
 
-struct Generator::GeneratorPrivate {
-    const ApiExtractor* apiextractor;
+struct Generator::GeneratorPrivate
+{
+    const ApiExtractor* apiextractor = nullptr;
     QString outDir;
     // License comment
     QString licenseComment;
@@ -468,7 +469,7 @@ AbstractMetaFunctionList Generator::implicitConversions(const AbstractMetaType*
 bool Generator::isObjectType(const TypeEntry* type)
 {
     if (type->isComplex())
-        return Generator::isObjectType((const ComplexTypeEntry*)type);
+        return Generator::isObjectType(static_cast<const ComplexTypeEntry *>(type));
     return type->isObject();
 }
 bool Generator::isObjectType(const ComplexTypeEntry* type)
@@ -586,7 +587,7 @@ QString Generator::minimalConstructor(const AbstractMetaType* type) const
         return QLatin1String("static_cast< ::") + type->typeEntry()->qualifiedCppName() + QLatin1String(" *>(0)");
 
     if (type->typeEntry()->isComplex()) {
-        const ComplexTypeEntry* cType = reinterpret_cast<const ComplexTypeEntry*>(type->typeEntry());
+        const ComplexTypeEntry* cType = static_cast<const ComplexTypeEntry*>(type->typeEntry());
         QString ctor = cType->defaultConstructor();
         if (!ctor.isEmpty())
             return ctor;
@@ -617,7 +618,7 @@ QString Generator::minimalConstructor(const TypeEntry* type) const
         return type->qualifiedCppName() + QLatin1String("(0)");
 
     if (type->isPrimitive()) {
-        QString ctor = reinterpret_cast<const PrimitiveTypeEntry*>(type)->defaultConstructor();
+        QString ctor = static_cast<const PrimitiveTypeEntry*>(type)->defaultConstructor();
         // If a non-C++ (i.e. defined by the user) primitive type does not have
         // a default constructor defined by the user, the empty constructor is
         // heuristically returned. If this is wrong the build of the generated
@@ -638,7 +639,7 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
     if (!metaClass)
         return QString();
 
-    const ComplexTypeEntry* cType = reinterpret_cast<const ComplexTypeEntry*>(metaClass->typeEntry());
+    const ComplexTypeEntry* cType = static_cast<const ComplexTypeEntry*>(metaClass->typeEntry());
     if (cType->hasDefaultConstructor())
         return cType->defaultConstructor();
 
diff --git a/sources/shiboken2/generator/main.cpp b/sources/shiboken2/generator/main.cpp
index 67d838ce8..c996c7cc3 100644
--- a/sources/shiboken2/generator/main.cpp
+++ b/sources/shiboken2/generator/main.cpp
@@ -386,7 +386,6 @@ static void parseIncludePathOption(const QString &option, HeaderType headerType,
 {
     const CommandArgumentMap::iterator it = args.find(option);
     if (it != args.end()) {
-        const QString path = it.value();
         const QStringList includePathListList =
             it.value().split(QLatin1String(PATH_SPLITTER), QString::SkipEmptyParts);
         args.erase(it);
diff --git a/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp b/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
index bc0ecc094..e8f09df4a 100644
--- a/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
+++ b/sources/shiboken2/generator/qtdoc/qtdocgenerator.cpp
@@ -303,7 +303,7 @@ QTextStream &operator<<(QTextStream &str, const QtXmlToSphinx::LinkContext &link
 }
 
 QtXmlToSphinx::QtXmlToSphinx(QtDocGenerator* generator, const QString& doc, const QString& context)
-        : m_context(context), m_generator(generator), m_insideBold(false), m_insideItalic(false)
+        : m_tableHasHeader(false), m_context(context), m_generator(generator), m_insideBold(false), m_insideItalic(false)
 {
     m_handlerMap.insert(QLatin1String("heading"), &QtXmlToSphinx::handleHeadingTag);
     m_handlerMap.insert(QLatin1String("brief"), &QtXmlToSphinx::handleParaTag);
@@ -1511,11 +1511,10 @@ QString QtDocGenerator::fileNameForContext(GeneratorContext &context) const
     const AbstractMetaClass *metaClass = context.metaClass();
     if (!context.forSmartPointer()) {
         return getClassTargetFullName(metaClass, false) + 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 QtDocGenerator::writeFormattedText(QTextStream &s, const Documentation &doc,
@@ -1532,7 +1531,7 @@ void QtDocGenerator::writeFormattedText(QTextStream &s, const Documentation &doc
     } else {
         const QString &value = doc.value();
         const QVector<QStringRef> lines = value.splitRef(QLatin1Char('\n'));
-        int typesystemIndentation = std::numeric_limits<int>().max();
+        int typesystemIndentation = std::numeric_limits<int>::max();
         // check how many spaces must be removed from the beginning of each line
         for (const QStringRef &line : lines) {
             const auto it = std::find_if(line.cbegin(), line.cend(),
@@ -1540,7 +1539,7 @@ void QtDocGenerator::writeFormattedText(QTextStream &s, const Documentation &doc
             if (it != line.cend())
                 typesystemIndentation = qMin(typesystemIndentation, int(it - line.cbegin()));
         }
-        if (typesystemIndentation == std::numeric_limits<int>().max())
+        if (typesystemIndentation == std::numeric_limits<int>::max())
             typesystemIndentation = 0;
         for (const QStringRef &line : lines) {
             s << INDENT
@@ -1675,7 +1674,7 @@ void QtDocGenerator::writeFunctionList(QTextStream& s, const AbstractMetaClass*
             functionList << str;
     }
 
-    if ((functionList.size() > 0) || (staticFunctionList.size() > 0)) {
+    if (!functionList.isEmpty() || !staticFunctionList.isEmpty()) {
         QtXmlToSphinx::Table functionTable;
 
         s << endl
@@ -1692,7 +1691,7 @@ void QtDocGenerator::writeFunctionList(QTextStream& s, const AbstractMetaClass*
 
 void QtDocGenerator::writeFunctionBlock(QTextStream& s, const QString& title, QStringList& functions)
 {
-    if (functions.size() > 0) {
+    if (!functions.isEmpty()) {
         s << title << endl
           << QString(title.size(), QLatin1Char('^')) << endl;
 
@@ -1775,7 +1774,8 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
         writeFormattedText(s, func->documentation(), cppClass);
 }
 
-QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* cppClass, const AbstractMetaFunction* func)
+QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* /* cppClass */,
+                                         const AbstractMetaFunction* func)
 {
     QString ret;
     int optArgs = 0;
@@ -1857,8 +1857,7 @@ void QtDocGenerator::writeDocSnips(QTextStream &s,
                 if (row.trimmed().size() == 0) {
                     if (currenRow == 0)
                         continue;
-                    else
-                        s << endl;
+                    s << endl;
                 }
 
                 if (currenRow == 0) {
@@ -2122,7 +2121,7 @@ void QtDocGenerator::writeModuleDocumentation()
 
         s << ".. module:: " << it.key() << endl << endl;
 
-        QString title = it.key();
+        const QString &title = it.key();
         s << title << endl;
         s << Pad('*', title.length()) << endl << endl;
 
@@ -2277,10 +2276,10 @@ bool QtDocGenerator::doSetup()
         qCWarning(lcShiboken) << "Documentation data dir and/or Qt source dir not informed, "
                                  "documentation will not be extracted from Qt sources.";
         return false;
-    } else {
-        m_docParser->setDocumentationDataDirectory(m_docDataDir);
-        m_docParser->setLibrarySourceDirectory(m_libSourceDir);
     }
+
+    m_docParser->setDocumentationDataDirectory(m_docDataDir);
+    m_docParser->setLibrarySourceDirectory(m_libSourceDir);
     return true;
 }
 
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;