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>

14 files changed, 118 insertions, 158 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,