Replace foreach by range-based for

foreach will be deprecated in Qt.

Change-Id: I8b3398bb543056de6dd11d18977928ae719819a2
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

26 files changed, 769 insertions, 623 deletions

diff --git a/ApiExtractor/abstractmetabuilder.cpp b/ApiExtractor/abstractmetabuilder.cpp
index f8abab4..d307d77 100644
--- a/ApiExtractor/abstractmetabuilder.cpp
+++ b/ApiExtractor/abstractmetabuilder.cpp
@@ -165,19 +165,19 @@ QSet<QString> AbstractMetaBuilder::qtMetaTypeDeclaredTypeNames() const
 void AbstractMetaBuilderPrivate::checkFunctionModifications()
 {
     TypeDatabase *types = TypeDatabase::instance();
-    SingleTypeEntryHash entryHash = types->entries();
-    QList<TypeEntry*> entries = entryHash.values();
+    const SingleTypeEntryHash entryHash = types->entries();
 
-    foreach (TypeEntry* entry, entries) {
+    for (SingleTypeEntryHash::const_iterator it = entryHash.cbegin(), end = entryHash.cend(); it != end; ++it) {
+        const TypeEntry *entry = it.value();
         if (!entry)
             continue;
         if (!entry->isComplex() || entry->codeGeneration() == TypeEntry::GenerateNothing)
             continue;
 
-        ComplexTypeEntry* centry = static_cast<ComplexTypeEntry*>(entry);
+        const ComplexTypeEntry* centry = static_cast<const ComplexTypeEntry*>(entry);
         FunctionModificationList modifications = centry->functionModifications();
 
-        foreach (const FunctionModification &modification, modifications) {
+        for (const FunctionModification &modification : qAsConst(modifications)) {
             QString signature = modification.signature;
 
             QString name = signature.trimmed();
@@ -187,10 +187,10 @@ void AbstractMetaBuilderPrivate::checkFunctionModifications()
             if (!clazz)
                 continue;
 
-            AbstractMetaFunctionList functions = clazz->functions();
+            const AbstractMetaFunctionList functions = clazz->functions();
             bool found = false;
             QStringList possibleSignatures;
-            foreach (AbstractMetaFunction *function, functions) {
+            for (AbstractMetaFunction *function : functions) {
                 if (function->minimalSignature() == signature && function->implementingClass() == clazz) {
                     found = true;
                     break;
@@ -424,7 +424,8 @@ void AbstractMetaBuilderPrivate::fixQObjectForScope(const FileModelItem &dom,
                                                     const TypeDatabase *types,
                                                     const NamespaceModelItem &scope)
 {
-    foreach (const ClassModelItem &item, scope->classes()) {
+    const ClassList &scopeClasses = scope->classes();
+    for (const ClassModelItem &item : scopeClasses) {
         QString qualifiedName = item->qualifiedName().join(colonColon());
         TypeEntry* entry = types->findType(qualifiedName);
         if (entry) {
@@ -434,7 +435,7 @@ void AbstractMetaBuilderPrivate::fixQObjectForScope(const FileModelItem &dom,
     }
 
     const NamespaceList &namespaces = scope->namespaces();
-    foreach (const NamespaceModelItem &n, namespaces) {
+    for (const NamespaceModelItem &n : namespaces) {
         if (scope != n)
             fixQObjectForScope(dom, types, n);
     }
@@ -442,7 +443,7 @@ void AbstractMetaBuilderPrivate::fixQObjectForScope(const FileModelItem &dom,
 
 void AbstractMetaBuilderPrivate::sortLists()
 {
-    foreach (AbstractMetaClass *cls, m_metaClasses)
+    for (AbstractMetaClass *cls : qAsConst(m_metaClasses))
         cls->sortFunctions();
 }
 
@@ -476,7 +477,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     // Start the generation...
     const ClassList &typeValues = dom->classes();
     ReportHandler::setProgressReference(typeValues);
-    foreach (const ClassModelItem &item, typeValues) {
+    for (const ClassModelItem &item : typeValues) {
         ReportHandler::progress(QLatin1String("Generating class model..."));
         AbstractMetaClass *cls = traverseClass(dom, item);
         if (!cls)
@@ -486,8 +487,9 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     }
 
     // We need to know all global enums
-    ReportHandler::setProgressReference(dom->enums());
-    foreach (const EnumModelItem &item, dom->enums()) {
+    const EnumList &enums = dom->enums();
+    ReportHandler::setProgressReference(enums);
+    for (const EnumModelItem &item : enums) {
         ReportHandler::progress(QLatin1String("Generating enum model..."));
         AbstractMetaEnum *metaEnum = traverseEnum(item, 0, QSet<QString>());
         if (metaEnum) {
@@ -498,7 +500,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
 
     const QSet<NamespaceModelItem> &namespaceTypeValues = dom->uniqueNamespaces();
     ReportHandler::setProgressReference(namespaceTypeValues);
-    foreach (NamespaceModelItem item, namespaceTypeValues) {
+    for (NamespaceModelItem item : namespaceTypeValues) {
         ReportHandler::progress(QLatin1String("Generating namespace model..."));
         AbstractMetaClass *metaClass = traverseNamespace(dom, item);
         if (metaClass)
@@ -507,9 +509,9 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
 
     // Go through all typedefs to see if we have defined any
     // specific typedefs to be used as classes.
-    TypeDefList typeDefs = dom->typeDefs();
+    const TypeDefList typeDefs = dom->typeDefs();
     ReportHandler::setProgressReference(typeDefs);
-    foreach (const TypeDefModelItem &typeDef, typeDefs) {
+    for (const TypeDefModelItem &typeDef : typeDefs) {
         ReportHandler::progress(QLatin1String("Resolving typedefs..."));
         AbstractMetaClass* cls = traverseTypeDef(dom, typeDef);
         addAbstractMetaClass(cls);
@@ -517,14 +519,15 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
 
     figureOutEnumValues();
 
-    foreach (const ClassModelItem &item, typeValues)
+    for (const ClassModelItem &item : typeValues)
         traverseClassMembers(item);
 
-    foreach (const NamespaceModelItem &item, namespaceTypeValues)
+    for (const NamespaceModelItem &item : namespaceTypeValues)
         traverseNamespaceMembers(item);
 
     // Global functions
-    foreach (const FunctionModelItem &func, dom->functions()) {
+    const FunctionList &functions = dom->functions();
+    for (const FunctionModelItem &func : functions) {
         if (func->accessPolicy() != CodeModel::Public || func->name().startsWith(QLatin1String("operator")))
             continue;
 
@@ -552,14 +555,14 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     }
 
     ReportHandler::setProgressReference(m_metaClasses);
-    foreach (AbstractMetaClass* cls, m_metaClasses) {
+    for (AbstractMetaClass *cls : qAsConst(m_metaClasses)) {
         ReportHandler::progress(QLatin1String("Fixing class inheritance..."));
         if (!cls->isInterface() && !cls->isNamespace())
             setupInheritance(cls);
     }
 
     ReportHandler::setProgressReference(m_metaClasses);
-    foreach (AbstractMetaClass* cls, m_metaClasses) {
+    for (AbstractMetaClass *cls : qAsConst(m_metaClasses)) {
         ReportHandler::progress(QLatin1String("Detecting inconsistencies in class model..."));
         cls->fixFunctions();
 
@@ -580,11 +583,10 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
         if (cls->isAbstract() && !cls->isInterface())
             cls->typeEntry()->setLookupName(cls->typeEntry()->targetLangName() + QLatin1String("$ConcreteWrapper"));
     }
-    TypeEntryHash allEntries = types->allEntries();
+    const TypeEntryHash allEntries = types->allEntries();
     ReportHandler::progress(QLatin1String("Detecting inconsistencies in typesystem..."));
-    foreach (QList<TypeEntry*> entries, allEntries) {
-        foreach (TypeEntry* entry, entries) {
-
+    for (TypeEntryHash::const_iterator it = allEntries.cbegin(), end = allEntries.cend(); it != end; ++it) {
+        for (TypeEntry *entry : it.value()) {
             if (entry->isPrimitive())
                 continue;
 
@@ -600,9 +602,10 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                                       .arg(entry->qualifiedCppName());
             } else if (entry->generateCode() && entry->type() == TypeEntry::FunctionType) {
                 const FunctionTypeEntry* fte = static_cast<const FunctionTypeEntry*>(entry);
-                foreach (const QString &signature, fte->signatures()) {
+                const QStringList &signatures = fte->signatures();
+                for (const QString &signature : signatures) {
                     bool ok = false;
-                    foreach (AbstractMetaFunction* func, m_globalFunctions) {
+                    for (AbstractMetaFunction* func : qAsConst(m_globalFunctions)) {
                         if (signature == func->minimalSignature()) {
                             ok = true;
                             break;
@@ -622,7 +625,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
                 if (cls) {
                     enumFound = cls->findEnum(entry->targetLangName());
                 } else { // Global enum
-                    foreach (AbstractMetaEnum* metaEnum, m_enums) {
+                    for (AbstractMetaEnum *metaEnum : qAsConst(m_enums)) {
                         if (metaEnum->typeEntry() == entry) {
                             enumFound = true;
                             break;
@@ -641,14 +644,14 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     }
 
     {
-        FunctionList hashFunctions = dom->findFunctions(QLatin1String("qHash"));
-        foreach (const FunctionModelItem &item, hashFunctions)
+        const FunctionList &hashFunctions = dom->findFunctions(QLatin1String("qHash"));
+        for (const FunctionModelItem &item : hashFunctions)
             registerHashFunction(item);
     }
 
     {
-        FunctionList hashFunctions = dom->findFunctions(QLatin1String("operator<<"));
-        foreach (const FunctionModelItem &item, hashFunctions)
+        const FunctionList &streamOps = dom->findFunctions(QLatin1String("operator<<"));
+        for (const FunctionModelItem &item : streamOps)
             registerToStringCapability(item);
     }
 
@@ -665,7 +668,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
         const FunctionList potentiallyBinaryOperators =
             dom->findFunctions(QStringLiteral("operator*"))
             + dom->findFunctions(QStringLiteral("operator&"));
-        foreach (const FunctionModelItem &item, potentiallyBinaryOperators) {
+        for (const FunctionModelItem &item : potentiallyBinaryOperators) {
             if (!item->arguments().isEmpty())
                 binaryOperators.append(item);
         }
@@ -676,14 +679,14 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
         binaryOperators.append(dom->findFunctions(QStringLiteral("operator~")));
         binaryOperators.append(dom->findFunctions(QStringLiteral("operator>")));
 
-        foreach (const FunctionModelItem &item, binaryOperators)
+        for (const FunctionModelItem &item : qAsConst(binaryOperators))
             traverseOperatorFunction(item);
     }
 
     {
-        FunctionList streamOperators = dom->findFunctions(QLatin1String("operator<<"))
-                                       + dom->findFunctions(QLatin1String("operator>>"));
-        foreach (const FunctionModelItem &item, streamOperators)
+        const FunctionList streamOperators = dom->findFunctions(QLatin1String("operator<<"))
+            + dom->findFunctions(QLatin1String("operator>>"));
+        for (const FunctionModelItem &item : streamOperators)
             traverseStreamOperator(item);
     }
 
@@ -693,7 +696,7 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     // sort all classes topologically
     m_metaClasses = classesTopologicalSorted();
 
-    foreach (AbstractMetaClass* cls, m_metaClasses) {
+    for (AbstractMetaClass* cls : qAsConst(m_metaClasses)) {
 //         setupEquals(cls);
 //         setupComparable(cls);
         setupClonable(cls);
@@ -713,7 +716,8 @@ void AbstractMetaBuilderPrivate::traverseDom(const FileModelItem &dom)
     m_currentClass = 0;
 
     // Functions added to the module on the type system.
-    foreach (const AddedFunction &addedFunc, types->globalUserFunctions()) {
+    const AddedFunctionList &globalUserFunctions = types->globalUserFunctions();
+    for (const AddedFunction &addedFunc : globalUserFunctions) {
         AbstractMetaFunction* metaFunc = traverseFunction(addedFunc);
         metaFunc->setFunctionType(AbstractMetaFunction::NormalFunction);
         m_globalFunctions << metaFunc;
@@ -797,8 +801,8 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
     pushScope(namespaceItem);
     m_namespacePrefix = currentScope()->qualifiedName().join(colonColon());
 
-    ClassList classes = namespaceItem->classes();
-    foreach (const ClassModelItem &cls, classes) {
+    const ClassList &classes = namespaceItem->classes();
+    for (const ClassModelItem &cls : classes) {
         AbstractMetaClass* mjc = traverseClass(dom, cls);
         if (mjc) {
             metaClass->addInnerClass(mjc);
@@ -810,7 +814,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
     // Go through all typedefs to see if we have defined any
     // specific typedefs to be used as classes.
     const TypeDefList typeDefs = namespaceItem->typeDefs();
-    foreach (const TypeDefModelItem &typeDef, typeDefs) {
+    for (const TypeDefModelItem &typeDef : typeDefs) {
         AbstractMetaClass *cls = traverseTypeDef(dom, typeDef);
         if (cls) {
             metaClass->addInnerClass(cls);
@@ -821,7 +825,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseNamespace(const FileModel
 
     // Traverse namespaces recursively
     const QSet<NamespaceModelItem> &innerNamespaces = namespaceItem->uniqueNamespaces();
-    foreach (const NamespaceModelItem &ni, innerNamespaces) {
+    for (const NamespaceModelItem &ni : innerNamespaces) {
         AbstractMetaClass* mjc = traverseNamespace(dom, ni);
         if (mjc) {
             metaClass->addInnerClass(mjc);
@@ -981,8 +985,8 @@ void AbstractMetaBuilderPrivate::figureOutEnumValuesForClass(AbstractMetaClass *
     if (classes->contains(metaClass))
         return;
 
-    AbstractMetaEnumList enums = metaClass->enums();
-    foreach (AbstractMetaEnum* e, enums) {
+    const AbstractMetaEnumList &enums = metaClass->enums();
+    for (AbstractMetaEnum* e : enums) {
         if (!e) {
             qCWarning(lcShiboken).noquote().nospace() << "bad enum in class " << metaClass->name();
             continue;
@@ -1005,10 +1009,10 @@ void AbstractMetaBuilderPrivate::figureOutEnumValues()
     // Keep a set of classes that we already traversed. We use this to
     // enforce that we traverse base classes prior to subclasses.
     QSet<AbstractMetaClass*> classes;
-    foreach (AbstractMetaClass *c, m_metaClasses)
+    for (AbstractMetaClass *c : qAsConst(m_metaClasses))
         figureOutEnumValuesForClass(c, &classes);
 
-    foreach (AbstractMetaEnum* metaEnum, m_globalEnums) {
+    for (AbstractMetaEnum* metaEnum : qAsConst(m_globalEnums)) {
         AbstractMetaEnumValueList enumValues = metaEnum->values();
         int value = 0;
         for (int i = 0; i < enumValues.size(); ++i) {
@@ -1021,9 +1025,11 @@ void AbstractMetaBuilderPrivate::figureOutEnumValues()
 
 void AbstractMetaBuilderPrivate::figureOutDefaultEnumArguments()
 {
-    foreach (AbstractMetaClass* metaClass, m_metaClasses) {
-        foreach (AbstractMetaFunction* metaFunction, metaClass->functions()) {
-            foreach (AbstractMetaArgument *arg, metaFunction->arguments()) {
+    for (AbstractMetaClass* metaClass : qAsConst(m_metaClasses)) {
+        const AbstractMetaFunctionList &functions = metaClass->functions();
+        for (AbstractMetaFunction* metaFunction : functions) {
+            const AbstractMetaArgumentList &arguments = metaFunction->arguments();
+            for (AbstractMetaArgument *arg : arguments) {
                 QString expr = arg->defaultValueExpression();
                 if (expr.isEmpty())
                     continue;
@@ -1059,7 +1065,8 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(EnumModelItem enumIte
         typeEntry = TypeDatabase::instance()->findType(qualifiedName);
     } else {
         QStringList tmpQualifiedName = enumItem->qualifiedName();
-        foreach (const EnumeratorModelItem& enumValue, enumItem->enumerators()) {
+        const EnumeratorList &enums = enumItem->enumerators();
+        for (const EnumeratorModelItem& enumValue : enums) {
             tmpQualifiedName.removeLast();
             tmpQualifiedName << enumValue->name();
             qualifiedName = tmpQualifiedName.join(colonColon());
@@ -1115,7 +1122,8 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(EnumModelItem enumIte
     if (ReportHandler::isDebug(ReportHandler::MediumDebug))
         qCDebug(lcShiboken) << " - traversing enum " << metaEnum->fullName();
 
-    foreach (const EnumeratorModelItem &value, enumItem->enumerators()) {
+    const EnumeratorList &enums = enumItem->enumerators();
+    for (const EnumeratorModelItem &value : enums) {
 
         AbstractMetaEnumValue *metaEnumValue = q->createMetaEnumValue();
         metaEnumValue->setName(value->name());
@@ -1144,7 +1152,8 @@ AbstractMetaEnum *AbstractMetaBuilderPrivate::traverseEnum(EnumModelItem enumIte
     metaEnum->setOriginalAttributes(metaEnum->attributes());
 
     // Register all enum values on Type database
-    foreach(EnumeratorModelItem e, enumItem->enumerators()) {
+    const EnumeratorList &enumerators = enumItem->enumerators();
+    for (EnumeratorModelItem e : enumItem->enumerators()) {
         QString name;
         if (enclosing) {
             name += enclosing->name();
@@ -1284,7 +1293,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
     // Inner classes
     {
         const ClassList &innerClasses = classItem->classes();
-        foreach (const ClassModelItem &ci, innerClasses) {
+        for (const ClassModelItem &ci : innerClasses) {
             AbstractMetaClass *cl = traverseClass(dom, ci);
             if (cl) {
                 cl->setEnclosingClass(metaClass);
@@ -1298,7 +1307,7 @@ AbstractMetaClass *AbstractMetaBuilderPrivate::traverseClass(const FileModelItem
     // Go through all typedefs to see if we have defined any
     // specific typedefs to be used as classes.
     const TypeDefList typeDefs = classItem->typeDefs();
-    foreach (const TypeDefModelItem &typeDef, typeDefs) {
+    for (const TypeDefModelItem &typeDef : typeDefs) {
         AbstractMetaClass *cls = traverseTypeDef(dom, typeDef);
         if (cls) {
             cls->setEnclosingClass(metaClass);
@@ -1325,7 +1334,7 @@ void AbstractMetaBuilderPrivate::traverseScopeMembers(ScopeModelItem item,
 
     // Inner classes
     const ClassList &innerClasses = item->classes();
-    foreach (const ClassModelItem& ci, innerClasses)
+    for (const ClassModelItem& ci : innerClasses)
         traverseClassMembers(ci);
 }
 
@@ -1376,7 +1385,7 @@ void AbstractMetaBuilderPrivate::traverseNamespaceMembers(NamespaceModelItem ite
 
     // Inner namespaces
     const QSet<NamespaceModelItem> &innerNamespaces = item->uniqueNamespaces();
-    foreach (const NamespaceModelItem &ni, innerNamespaces)
+    for (const NamespaceModelItem &ni : innerNamespaces)
         traverseNamespaceMembers(ni);
 
     m_currentClass = oldCurrentClass;
@@ -1451,7 +1460,8 @@ AbstractMetaField *AbstractMetaBuilderPrivate::traverseField(VariableModelItem f
 void AbstractMetaBuilderPrivate::traverseFields(ScopeModelItem scope_item,
                                                 AbstractMetaClass *metaClass)
 {
-    foreach (const VariableModelItem &field, scope_item->variables()) {
+    const VariableList &variables = scope_item->variables();
+    for (const VariableModelItem &field : variables) {
         AbstractMetaField* metaField = traverseField(field, metaClass);
 
         if (metaField && !metaField->isModifiedRemoved()) {
@@ -1578,7 +1588,7 @@ AbstractMetaFunctionList AbstractMetaBuilderPrivate::classFunctionList(const Sco
     AbstractMetaFunctionList result;
     const FunctionList &scopeFunctionList = scopeItem->functions();
     result.reserve(scopeFunctionList.size());
-    foreach (const FunctionModelItem &function, scopeItem->functions()) {
+    for (const FunctionModelItem &function : scopeFunctionList) {
         if (AbstractMetaFunction *metaFunction = traverseFunction(function))
             result.append(metaFunction);
     }
@@ -1617,7 +1627,7 @@ AbstractMetaFunctionList AbstractMetaBuilderPrivate::templateClassFunctionList(c
     const FunctionList &scopeFunctionList = scopeItem->functions();
     result.reserve(scopeFunctionList.size());
     unchangedFunctions.reserve(scopeFunctionList.size());
-    foreach (FunctionModelItem function, scopeItem->functions()) {
+    for (FunctionModelItem function : scopeFunctionList) {
         // This fixes method's arguments and return types that are templates
         // but the template variable wasn't declared in the C++ header.
         const bool templateTypeFixed =_fixFunctionModelItemTypes(function, metaClass);
@@ -1648,7 +1658,7 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
         ? classFunctionList(scopeItem)
         : templateClassFunctionList(scopeItem, metaClass);
 
-    foreach (AbstractMetaFunction *metaFunction, functions) {
+    for (AbstractMetaFunction *metaFunction : functions){
         metaFunction->setOriginalAttributes(metaFunction->attributes());
         if (metaClass->isNamespace())
             *metaFunction += AbstractMetaAttributes::Static;
@@ -1732,15 +1742,16 @@ void AbstractMetaBuilderPrivate::traverseFunctions(ScopeModelItem scopeItem,
 void AbstractMetaBuilderPrivate::fillAddedFunctions(AbstractMetaClass *metaClass)
 {
     // Add the functions added by the typesystem
-    foreach (const AddedFunction &addedFunc, metaClass->typeEntry()->addedFunctions())
+    const AddedFunctionList &addedFunctions = metaClass->typeEntry()->addedFunctions();
+    for (const AddedFunction &addedFunc : addedFunctions)
         traverseFunction(addedFunc, metaClass);
 }
 
 void AbstractMetaBuilderPrivate::applyFunctionModifications(AbstractMetaFunction *func)
 {
-    FunctionModificationList mods = func->modifications(func->implementingClass());
+    const FunctionModificationList &mods = func->modifications(func->implementingClass());
     AbstractMetaFunction& funcRef = *func;
-    foreach (const FunctionModification &mod, mods) {
+    for (const FunctionModification &mod : mods) {
         if (mod.isRenameModifier()) {
             func->setOriginalName(func->name());
             func->setName(mod.renamedTo());
@@ -1862,8 +1873,8 @@ bool AbstractMetaBuilderPrivate::setupInheritance(AbstractMetaClass *metaClass)
             }
             metaClass->addInterface(iface);
 
-            AbstractMetaClassList interfaces = iface->interfaces();
-            foreach (AbstractMetaClass* iface, interfaces)
+            const AbstractMetaClassList &interfaces = iface->interfaces();
+            for (AbstractMetaClass* iface : interfaces)
                 metaClass->addInterface(iface);
         }
     }
@@ -1875,8 +1886,8 @@ void AbstractMetaBuilderPrivate::traverseEnums(ScopeModelItem scopeItem,
                                                AbstractMetaClass *metaClass,
                                                const QStringList &enumsDeclarations)
 {
-    EnumList enums = scopeItem->enums();
-    foreach (const EnumModelItem &enumItem, enums) {
+    const EnumList &enums = scopeItem->enums();
+    for (const EnumModelItem &enumItem : enums) {
         AbstractMetaEnum* metaEnum = traverseEnum(enumItem, metaClass, QSet<QString>::fromList(enumsDeclarations));
         if (metaEnum) {
             metaClass->addEnum(metaEnum);
@@ -1997,8 +2008,9 @@ void AbstractMetaBuilderPrivate::fixArgumentNames(AbstractMetaFunction *func)
 {
     if (func->arguments().isEmpty())
         return;
-    foreach (const FunctionModification &mod, func->modifications(m_currentClass)) {
-        foreach (const ArgumentModification &argMod, mod.argument_mods) {
+    const FunctionModificationList &mods = func->modifications(m_currentClass);
+    for (const FunctionModification &mod : mods) {
+        for (const ArgumentModification &argMod : mod.argument_mods) {
             if (!argMod.renamed_to.isEmpty()) {
                 AbstractMetaArgument* arg = func->arguments().at(argMod.index - 1);
                 arg->setOriginalName(arg->name());
@@ -2007,18 +2019,18 @@ void AbstractMetaBuilderPrivate::fixArgumentNames(AbstractMetaFunction *func)
         }
     }
 
-    int i = 1;
-    foreach (AbstractMetaArgument* arg, func->arguments()) {
-        if (arg->name().isEmpty())
-            arg->setName(QLatin1String("arg__") + QString::number(i), false);
-        ++i;
+    AbstractMetaArgumentList arguments = func->arguments();
+    for (int i = 0, size = arguments.size(); i < size; ++i) {
+        if (arguments.at(i)->name().isEmpty())
+            arguments[i]->setName(QLatin1String("arg__") + QString::number(i + 1), false);
     }
 }
 
 static QString functionSignature(FunctionModelItem functionItem)
 {
     QStringList args;
-    foreach (const ArgumentModelItem &arg, functionItem->arguments())
+    const ArgumentList &arguments = functionItem->arguments();
+    for (const ArgumentModelItem &arg : arguments)
         args << arg->type().toString();
     return functionItem->name() + QLatin1Char('(') + args.join(QLatin1Char(',')) + QLatin1Char(')');
 }
@@ -2327,7 +2339,7 @@ AbstractMetaType *AbstractMetaBuilderPrivate::translateType(double vr,
 
         msg += QLatin1String("Remember to inform the full qualified name for the type you want to use.\nCandidates are:\n");
         candidates.sort();
-        foreach (const QString& candidate, candidates) {
+        for (const QString& candidate : qAsConst(candidates)) {
             msg += QLatin1String("    ") + candidate + QLatin1Char('\n');
         }
         qFatal(qPrintable(msg), NULL);
@@ -2340,7 +2352,7 @@ AbstractMetaType *AbstractMetaBuilderPrivate::translateType(double vr,
         metaType->setReferenceType(LValueReference);
     metaType->setConstant(typeInfo.isConstant);
     if (isTemplate) {
-        foreach (const QString& templateArg, templateArgs) {
+        for (const QString& templateArg : qAsConst(templateArgs)) {
             AbstractMetaType* metaArgType = translateType(vr, AddedFunction::TypeInfo::fromSignature(templateArg));
             metaType->addInstantiation(metaArgType);
         }
@@ -2479,7 +2491,8 @@ AbstractMetaType *AbstractMetaBuilderPrivate::translateType(const TypeInfo &_typ
 
         // 5.1.1 - Try using the class parents' scopes
         if (!type && !m_currentClass->baseClassNames().isEmpty()) {
-            foreach (const AbstractMetaClass* cls, getBaseClasses(m_currentClass)) {
+            const AbstractMetaClassList &baseClasses = getBaseClasses(m_currentClass);
+            for (const AbstractMetaClass *cls : baseClasses) {
                 type = findTypeEntryUsingContext(cls, qualifiedName);
                 if (type)
                     break;
@@ -2502,8 +2515,8 @@ AbstractMetaType *AbstractMetaBuilderPrivate::translateType(const TypeInfo &_typ
     // 8. No? Check if the current class is a template and this type is one
     //    of the parameters.
     if (!type && m_currentClass) {
-        QList<TypeEntry *> template_args = m_currentClass->templateArguments();
-        foreach (TypeEntry *te, template_args) {
+        const QList<TypeEntry *> &template_args = m_currentClass->templateArguments();
+        for (TypeEntry *te : template_args) {
             if (te->name() == qualifiedName)
                 type = te;
         }
@@ -2551,7 +2564,7 @@ AbstractMetaType *AbstractMetaBuilderPrivate::translateType(const TypeInfo &_typ
     metaType->setConstant(typeInfo.is_constant);
     metaType->setOriginalTypeDescription(_typei.toString());
 
-    foreach (const TypeParser::Info &ta, typeInfo.template_instantiations) {
+    for (const TypeParser::Info &ta : qAsConst(typeInfo.template_instantiations)) {
         TypeInfo info;
         info.setConstant(ta.is_constant);
         info.setReferenceType(ta.referenceType);
@@ -2604,8 +2617,9 @@ int AbstractMetaBuilderPrivate::findOutValueFromString(const QString &stringValu
         return enumValue->value();
     }
 
-    foreach (AbstractMetaEnum* metaEnum, m_globalEnums) {
-        foreach (AbstractMetaEnumValue* ev, metaEnum->values()) {
+    for (AbstractMetaEnum *metaEnum : qAsConst(m_globalEnums)) {
+        const AbstractMetaEnumValueList &values = metaEnum->values();
+        for (const AbstractMetaEnumValue *ev : values) {
             if (ev->name() == stringValue) {
                 ok = true;
                 return ev->value();
@@ -2688,7 +2702,8 @@ QString AbstractMetaBuilderPrivate::fixDefaultValue(ArgumentModelItem item,
 
             // Fix scope if the parameter is a field of the current class
             if (implementingClass) {
-                foreach (const AbstractMetaField* field, implementingClass->fields()) {
+                const AbstractMetaFieldList &fields = implementingClass->fields();
+                for (const AbstractMetaField *field : fields) {
                     if (defaultRegEx.cap(2) == field->name()) {
                         expr = defaultRegEx.cap(1) + implementingClass->name()
                                + colonColon() + defaultRegEx.cap(2) + defaultRegEx.cap(3);
@@ -2773,7 +2788,7 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::findTemplateClass(const QString &
         QString qualifiedName = info->qualified_name.join(colonColon());
 
         AbstractMetaClass* templ = 0;
-        foreach (AbstractMetaClass *c, m_templates) {
+        for (AbstractMetaClass *c : qAsConst(m_templates)) {
             if (c->typeEntry()->name() == qualifiedName) {
                 templ = c;
                 break;
@@ -2796,7 +2811,8 @@ AbstractMetaClass* AbstractMetaBuilderPrivate::findTemplateClass(const QString &
 AbstractMetaClassList AbstractMetaBuilderPrivate::getBaseClasses(const AbstractMetaClass *metaClass) const
 {
     AbstractMetaClassList baseClasses;
-    foreach (const QString& parent, metaClass->baseClassNames()) {
+    const QStringList &baseClassNames = metaClass->baseClassNames();
+    for (const QString& parent : baseClassNames) {
         AbstractMetaClass* cls = 0;
         if (parent.contains(QLatin1Char('<')))
             cls = findTemplateClass(parent, metaClass);
@@ -2813,7 +2829,8 @@ bool AbstractMetaBuilderPrivate::ancestorHasPrivateCopyConstructor(const Abstrac
 {
     if (metaClass->hasPrivateCopyConstructor())
         return true;
-    foreach (const AbstractMetaClass* cls, getBaseClasses(metaClass)) {
+    const AbstractMetaClassList &baseClasses = getBaseClasses(metaClass);
+    for (const AbstractMetaClass *cls : baseClasses) {
         if (ancestorHasPrivateCopyConstructor(cls))
             return true;
     }
@@ -2885,7 +2902,7 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
         subclass->setHasVirtualDestructor(templateClass->hasVirtualDestructor());
     }
 
-    foreach (const TypeParser::Info &i, targs) {
+    for (const TypeParser::Info &i : qAsConst(targs)) {
         QString typeName = i.qualified_name.join(colonColon());
         QStringList possibleNames;
         possibleNames << subclass->qualifiedCppName() + colonColon() + typeName;
@@ -2897,7 +2914,7 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
         TypeDatabase* typeDb = TypeDatabase::instance();
         TypeEntry* t = 0;
         QString templateParamName;
-        foreach (const QString &possibleName, possibleNames) {
+        for (const QString &possibleName : qAsConst(possibleNames)) {
             t = typeDb->findType(possibleName);
             if (t) {
                 QString templateParamName = possibleName;
@@ -2921,7 +2938,8 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
     }
 
     AbstractMetaFunctionList funcs = subclass->functions();
-    foreach (const AbstractMetaFunction* function, templateClass->functions()) {
+    const AbstractMetaFunctionList &templateClassFunctions = templateClass->functions();
+    for (const AbstractMetaFunction *function : templateClassFunctions) {
         if (function->isModifiedRemoved(TypeSystem::All))
             continue;
 
@@ -2936,7 +2954,8 @@ bool AbstractMetaBuilderPrivate::inheritTemplate(AbstractMetaClass *subclass,
             continue;
         }
 
-        foreach (AbstractMetaArgument* argument, function->arguments()) {
+        const AbstractMetaArgumentList &arguments = function->arguments();
+        for (AbstractMetaArgument *argument : arguments) {
             AbstractMetaType* atype = argument->type();
 
             AbstractMetaArgument *arg = argument->copy();
@@ -3075,7 +3094,7 @@ static AbstractMetaFunction* findCopyCtor(AbstractMetaClass* cls)
     AbstractMetaFunctionList functions = cls->queryFunctions(AbstractMetaClass::Invisible);
     functions <<  cls->queryFunctions(AbstractMetaClass::Visible);
 
-    foreach (AbstractMetaFunction* f, functions) {
+    for (AbstractMetaFunction *f : qAsConst(functions)) {
         const AbstractMetaFunction::FunctionType t = f->functionType();
         if (t == AbstractMetaFunction::CopyConstructorFunction || t == AbstractMetaFunction::AssignmentOperatorFunction)
             return f;
@@ -3115,8 +3134,8 @@ void AbstractMetaBuilderPrivate::setupClonable(AbstractMetaClass *cls)
 
 void AbstractMetaBuilderPrivate::setupExternalConversion(AbstractMetaClass *cls)
 {
-    AbstractMetaFunctionList convOps = cls->operatorOverloads(AbstractMetaClass::ConversionOp);
-    foreach (AbstractMetaFunction* func, convOps) {
+    const AbstractMetaFunctionList &convOps = cls->operatorOverloads(AbstractMetaClass::ConversionOp);
+    for (AbstractMetaFunction *func : convOps) {
         if (func->isModifiedRemoved())
             continue;
         AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_metaClasses, func->type()->typeEntry());
@@ -3124,7 +3143,8 @@ void AbstractMetaBuilderPrivate::setupExternalConversion(AbstractMetaClass *cls)
             continue;
         metaClass->addExternalConversionOperator(func);
     }
-    foreach (AbstractMetaClass* innerClass, cls->innerClasses())
+    const AbstractMetaClassList &innerClasses = cls->innerClasses();
+    for (AbstractMetaClass *innerClass : innerClasses)
         setupExternalConversion(innerClass);
 }
 
@@ -3204,7 +3224,7 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
     const AbstractMetaClassList& classList = cppClass ? cppClass->innerClasses() : m_metaClasses;
 
     int i = 0;
-    foreach (AbstractMetaClass* clazz, classList) {
+    for (AbstractMetaClass *clazz : classList) {
         if (map.contains(clazz->qualifiedCppName()))
             continue;
         map[clazz->qualifiedCppName()] = i;
@@ -3214,7 +3234,7 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
 
     Graph graph(map.count());
 
-    foreach (const Dependency &dep, additionalDependencies) {
+    for (const Dependency &dep : additionalDependencies) {
         const int parentIndex = map.value(dep.parent, -1);
         const int childIndex = map.value(dep.child, -1);
         if (parentIndex >= 0 && childIndex >= 0) {
@@ -3229,12 +3249,12 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
     // TODO choose a better name to these regexs
     QRegExp regex1(QLatin1String("\\(.*\\)"));
     QRegExp regex2(QLatin1String("::.*"));
-    foreach (AbstractMetaClass* clazz, classList) {
+    for (AbstractMetaClass *clazz : classList) {
         if (clazz->enclosingClass() && map.contains(clazz->enclosingClass()->qualifiedCppName()))
             graph.addEdge(map[clazz->enclosingClass()->qualifiedCppName()], map[clazz->qualifiedCppName()]);
 
-        AbstractMetaClassList bases = getBaseClasses(clazz);
-        foreach(AbstractMetaClass* baseClass, bases) {
+        const AbstractMetaClassList &bases = getBaseClasses(clazz);
+        for (AbstractMetaClass *baseClass : bases) {
             // Fix polymorphic expression
             if (clazz->baseClass() == baseClass)
                 clazz->setBaseClass(baseClass);
@@ -3243,8 +3263,10 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
                 graph.addEdge(map[baseClass->qualifiedCppName()], map[clazz->qualifiedCppName()]);
         }
 
-        foreach (AbstractMetaFunction* func, clazz->functions()) {
-            foreach (AbstractMetaArgument* arg, func->arguments()) {
+        const AbstractMetaFunctionList &functions = clazz->functions();
+        for (AbstractMetaFunction *func : functions) {
+            const AbstractMetaArgumentList &arguments = func->arguments();
+            for (AbstractMetaArgument *arg : arguments) {
                 // check methods with default args
                 QString defaultExpression = arg->originalDefaultValueExpression();
                 if (!defaultExpression.isEmpty()) {
@@ -3258,7 +3280,7 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
                     QString exprClassName = clazz->qualifiedCppName() + colonColon() + defaultExpression;
                     if (!map.contains(exprClassName)) {
                         bool found = false;
-                        foreach(AbstractMetaClass* baseClass, bases) {
+                        for (AbstractMetaClass *baseClass : bases) {
                             exprClassName = baseClass->qualifiedCppName() + colonColon() + defaultExpression;
                             if (map.contains(exprClassName)) {
                                 found = true;
@@ -3294,7 +3316,7 @@ AbstractMetaClassList AbstractMetaBuilderPrivate::classesTopologicalSorted(const
             << "Cyclic dependency found! Graph can be found at "
             << QDir::toNativeSeparators(tempFile.fileName());
     } else {
-        foreach (int i, unmappedResult) {
+        for (int i : qAsConst(unmappedResult)) {
             Q_ASSERT(reverseMap.contains(i));
             if (!reverseMap[i]->isInterface())
                 result << reverseMap[i];
@@ -3315,7 +3337,7 @@ AbstractMetaArgumentList AbstractMetaBuilderPrivate::reverseList(const AbstractM
     AbstractMetaArgumentList ret;
 
     int index = list.size();
-    foreach (AbstractMetaArgument* arg, list) {
+    for (AbstractMetaArgument *arg : list) {
         arg->setArgumentIndex(index);
         ret.prepend(arg);
         index--;
diff --git a/ApiExtractor/abstractmetalang.cpp b/ApiExtractor/abstractmetalang.cpp
index b861f1b..a8fc8ea 100644
--- a/ApiExtractor/abstractmetalang.cpp
+++ b/ApiExtractor/abstractmetalang.cpp
@@ -347,8 +347,8 @@ AbstractMetaFunction::~AbstractMetaFunction()
  */
 bool AbstractMetaFunction::isModifiedRemoved(int types) const
 {
-    FunctionModificationList mods = modifications(implementingClass());
-    foreach (const FunctionModification &mod, mods) {
+    const FunctionModificationList &mods = modifications(implementingClass());
+    for (const FunctionModification &mod : mods) {
         if (!mod.isRemoveModifier())
             continue;
 
@@ -368,7 +368,7 @@ bool AbstractMetaFunction::needsCallThrough() const
     if (argumentsHaveNativeId() || !isStatic())
         return true;
 
-    foreach (const AbstractMetaArgument *arg, arguments()) {
+    for (const AbstractMetaArgument *arg : m_arguments) {
         if (arg->type()->isArray() || arg->type()->isTargetLangEnum() || arg->type()->isTargetLangFlags())
             return true;
     }
@@ -388,8 +388,8 @@ bool AbstractMetaFunction::needsCallThrough() const
 bool AbstractMetaFunction::needsSuppressUncheckedWarning() const
 {
     for (int i = -1; i <= arguments().size(); ++i) {
-        QList<ReferenceCount> referenceCounts = this->referenceCounts(implementingClass(), i);
-        foreach (const ReferenceCount &referenceCount, referenceCounts) {
+        const QList<ReferenceCount> &referenceCounts = this->referenceCounts(implementingClass(), i);
+        for (const ReferenceCount &referenceCount : referenceCounts) {
             if (referenceCount.action != ReferenceCount::Set)
                 return true;
         }
@@ -400,8 +400,7 @@ bool AbstractMetaFunction::needsSuppressUncheckedWarning() const
 QString AbstractMetaFunction::marshalledName() const
 {
     QString returned = QLatin1String("__qt_") + name();
-    AbstractMetaArgumentList arguments = this->arguments();
-    foreach (const AbstractMetaArgument *arg, arguments) {
+    for (const AbstractMetaArgument *arg : m_arguments) {
         returned += QLatin1Char('_');
         if (arg->type()->isNativePointer()) {
             returned += QLatin1String("nativepointer");
@@ -510,7 +509,7 @@ AbstractMetaFunction *AbstractMetaFunction::copy() const
     cpy->setConstant(isConstant());
     cpy->setOriginalAttributes(originalAttributes());
 
-    foreach (AbstractMetaArgument *arg, arguments())
+    for (AbstractMetaArgument *arg : m_arguments)
     cpy->addArgument(arg->copy());
 
     Q_ASSERT((!type() && !cpy->type())
@@ -525,7 +524,7 @@ bool AbstractMetaFunction::usesRValueReferences() const
         return true;
     if (m_type && m_type->referenceType() == RValueReference)
         return true;
-    foreach (const AbstractMetaArgument *a, m_arguments) {
+    for (const AbstractMetaArgument *a : m_arguments) {
         if (a->type()->referenceType() == RValueReference)
             return true;
     }
@@ -604,9 +603,9 @@ QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaCl
 {
     QList<ReferenceCount> returned;
 
-    FunctionModificationList mods = this->modifications(cls);
-    foreach (const FunctionModification &mod, mods) {
-        foreach (const ArgumentModification &argumentMod, mod.argument_mods) {
+    const FunctionModificationList &mods = this->modifications(cls);
+    for (const FunctionModification &mod : mods) {
+        for (const ArgumentModification &argumentMod : mod.argument_mods) {
             if (argumentMod.index != idx && idx != -2)
                 continue;
             returned += argumentMod.referenceCounts;
@@ -619,9 +618,9 @@ QList<ReferenceCount> AbstractMetaFunction::referenceCounts(const AbstractMetaCl
 
 ArgumentOwner AbstractMetaFunction::argumentOwner(const AbstractMetaClass *cls, int idx) const
 {
-    FunctionModificationList mods = this->modifications(cls);
-    foreach (const FunctionModification &mod, mods) {
-        foreach (const ArgumentModification &argumentMod, mod.argument_mods) {
+    const FunctionModificationList &mods = this->modifications(cls);
+    for (const FunctionModification &mod : mods) {
+        for (const ArgumentModification &argumentMod : mod.argument_mods) {
             if (argumentMod.index != idx)
                 continue;
             return argumentMod.owner;
@@ -633,9 +632,9 @@ ArgumentOwner AbstractMetaFunction::argumentOwner(const AbstractMetaClass *cls,
 
 QString AbstractMetaFunction::replacedDefaultExpression(const AbstractMetaClass *cls, int key) const
 {
-    FunctionModificationList modifications = this->modifications(cls);
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(cls);
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index == key
                 && !argumentModification.replacedDefaultExpression.isEmpty()) {
                 return argumentModification.replacedDefaultExpression;
@@ -648,9 +647,9 @@ QString AbstractMetaFunction::replacedDefaultExpression(const AbstractMetaClass
 
 bool AbstractMetaFunction::removedDefaultExpression(const AbstractMetaClass *cls, int key) const
 {
-    FunctionModificationList modifications = this->modifications(cls);
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(cls);
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index == key
                 && argumentModification.removedDefaultExpression) {
                 return true;
@@ -664,9 +663,9 @@ bool AbstractMetaFunction::removedDefaultExpression(const AbstractMetaClass *cls
 bool AbstractMetaFunction::resetObjectAfterUse(int argumentIdx) const
 {
     const AbstractMetaClass *cls = declaringClass();
-    FunctionModificationList modifications = this->modifications(cls);
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(cls);
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index == argumentIdx && argumentModification.resetAfterUse)
                 return true;
         }
@@ -684,9 +683,9 @@ QString AbstractMetaFunction::nullPointerDefaultValue(const AbstractMetaClass *m
         cls = implementingClass();
 
     do {
-        FunctionModificationList modifications = this->modifications(cls);
-        foreach (const FunctionModification &modification, modifications) {
-            foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+        const FunctionModificationList &modifications = this->modifications(cls);
+        for (const FunctionModification &modification : modifications) {
+            for (const ArgumentModification &argumentModification : modification.argument_mods) {
                 if (argumentModification.index == argumentIdx
                     && argumentModification.noNullPointers) {
                     return argumentModification.nullPointerDefaultValue;
@@ -707,9 +706,9 @@ bool AbstractMetaFunction::nullPointersDisabled(const AbstractMetaClass *mainCla
         cls = implementingClass();
 
     do {
-        FunctionModificationList modifications = this->modifications(cls);
-        foreach (const FunctionModification &modification, modifications) {
-            foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+        const FunctionModificationList &modifications = this->modifications(cls);
+        for (const FunctionModification &modification : modifications) {
+            for (const ArgumentModification &argumentModification : modification.argument_mods) {
                 if (argumentModification.index == argumentIdx
                     && argumentModification.noNullPointers) {
                     return true;
@@ -725,13 +724,13 @@ bool AbstractMetaFunction::nullPointersDisabled(const AbstractMetaClass *mainCla
 
 QString AbstractMetaFunction::conversionRule(TypeSystem::Language language, int key) const
 {
-    FunctionModificationList modifications = this->modifications(declaringClass());
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(declaringClass());
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index != key)
                 continue;
 
-            foreach (const CodeSnip &snip, argumentModification.conversion_rules) {
+            for (const CodeSnip &snip : argumentModification.conversion_rules) {
                 if (snip.language == language && !snip.code().isEmpty())
                     return snip.code();
             }
@@ -743,9 +742,9 @@ QString AbstractMetaFunction::conversionRule(TypeSystem::Language language, int
 
 QString AbstractMetaFunction::argumentReplaced(int key) const
 {
-    FunctionModificationList modifications = this->modifications(declaringClass());
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(declaringClass());
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index == key && !argumentModification.replace_value.isEmpty())
                 return argumentModification.replace_value;
         }
@@ -757,9 +756,9 @@ QString AbstractMetaFunction::argumentReplaced(int key) const
 // FIXME If we remove a arg. in the method at the base class, it will not reflect here.
 bool AbstractMetaFunction::argumentRemoved(int key) const
 {
-    FunctionModificationList modifications = this->modifications(declaringClass());
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(declaringClass());
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index == key) {
                 if (argumentModification.removed)
                     return true;
@@ -772,8 +771,8 @@ bool AbstractMetaFunction::argumentRemoved(int key) const
 
 bool AbstractMetaFunction::isVirtualSlot() const
 {
-    FunctionModificationList modifications = this->modifications(declaringClass());
-    foreach (const FunctionModification &modification, modifications) {
+    const FunctionModificationList &modifications = this->modifications(declaringClass());
+    for (const FunctionModification &modification : modifications) {
         if (modification.isVirtualSlot())
             return true;
     }
@@ -785,9 +784,9 @@ bool AbstractMetaFunction::disabledGarbageCollection(const AbstractMetaClass *cl
 {
     typedef QHash<TypeSystem::Language, TypeSystem::Ownership>::const_iterator OwnershipMapIt;
 
-    FunctionModificationList modifications = this->modifications(cls);
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(cls);
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index != key)
                 continue;
 
@@ -804,8 +803,8 @@ bool AbstractMetaFunction::disabledGarbageCollection(const AbstractMetaClass *cl
 
 bool AbstractMetaFunction::isDeprecated() const
 {
-    FunctionModificationList modifications = this->modifications(declaringClass());
-    foreach (const FunctionModification &modification, modifications) {
+    const FunctionModificationList &modifications = this->modifications(declaringClass());
+    for (const FunctionModification &modification : modifications) {
         if (modification.isDeprecated())
             return true;
     }
@@ -814,8 +813,8 @@ bool AbstractMetaFunction::isDeprecated() const
 
 bool AbstractMetaFunction::isThread() const
 {
-    FunctionModificationList modifications = this->modifications(declaringClass());
-    foreach (const FunctionModification &modification, modifications) {
+    const FunctionModificationList &modifications = this->modifications(declaringClass());
+    for (const FunctionModification &modification : modifications) {
         if (modification.isThread())
             return true;
     }
@@ -824,8 +823,8 @@ bool AbstractMetaFunction::isThread() const
 
 bool AbstractMetaFunction::allowThread() const
 {
-    FunctionModificationList modifications = this->modifications(declaringClass());
-    foreach (const FunctionModification &modification, modifications) {
+    const FunctionModificationList &modifications = this->modifications(declaringClass());
+    for (const FunctionModification &modification : modifications) {
         if (modification.allowThread())
             return true;
     }
@@ -835,9 +834,9 @@ bool AbstractMetaFunction::allowThread() const
 
 TypeSystem::Ownership AbstractMetaFunction::ownership(const AbstractMetaClass *cls, TypeSystem::Language language, int key) const
 {
-    FunctionModificationList modifications = this->modifications(cls);
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(cls);
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index == key)
                 return argumentModification.ownerships.value(language, TypeSystem::InvalidOwnership);
         }
@@ -853,8 +852,8 @@ bool AbstractMetaFunction::isRemovedFromAllLanguages(const AbstractMetaClass *cl
 
 bool AbstractMetaFunction::isRemovedFrom(const AbstractMetaClass *cls, TypeSystem::Language language) const
 {
-    FunctionModificationList modifications = this->modifications(cls);
-    foreach (const FunctionModification &modification, modifications) {
+    const FunctionModificationList &modifications = this->modifications(cls);
+    for (const FunctionModification &modification : modifications) {
         if ((modification.removal & language) == language)
             return true;
     }
@@ -865,9 +864,9 @@ bool AbstractMetaFunction::isRemovedFrom(const AbstractMetaClass *cls, TypeSyste
 
 QString AbstractMetaFunction::typeReplaced(int key) const
 {
-    FunctionModificationList modifications = this->modifications(declaringClass());
-    foreach (const FunctionModification &modification, modifications) {
-        foreach (const ArgumentModification &argumentModification, modification.argument_mods) {
+    const FunctionModificationList &modifications = this->modifications(declaringClass());
+    for (const FunctionModification &modification : modifications) {
+        for (const ArgumentModification &argumentModification : modification.argument_mods) {
             if (argumentModification.index == key
                 && !argumentModification.modified_type.isEmpty()) {
                 return argumentModification.modified_type;
@@ -923,9 +922,9 @@ FunctionModificationList AbstractMetaFunction::modifications(const AbstractMetaC
         if ((implementor == implementor->baseClass()) ||
             (implementor == implementingClass() && (mods.size() > 0)))
                 break;
-        foreach (const AbstractMetaClass* interface, implementor->interfaces()) {
+        const AbstractMetaClassList &interfaces = implementor->interfaces();
+        for (const AbstractMetaClass *interface : interfaces)
             mods += this->modifications(interface);
-        }
         implementor = implementor->baseClass();
     }
     return mods;
@@ -950,7 +949,8 @@ bool AbstractMetaFunction::isCallOperator() const
 
 bool AbstractMetaFunction::hasInjectedCode() const
 {
-    foreach (const FunctionModification &mod, modifications(ownerClass())) {
+    const FunctionModificationList &mods = modifications(ownerClass());
+    for (const FunctionModification &mod : mods) {
         if (mod.isCodeInjection())
             return true;
     }
@@ -960,12 +960,12 @@ bool AbstractMetaFunction::hasInjectedCode() const
 CodeSnipList AbstractMetaFunction::injectedCodeSnips(TypeSystem::CodeSnipPosition position, TypeSystem::Language language) const
 {
     CodeSnipList result;
-    foreach (const FunctionModification &mod, modifications(ownerClass())) {
+    const FunctionModificationList &mods = modifications(ownerClass());
+    for (const FunctionModification &mod : mods) {
         if (mod.isCodeInjection()) {
-            QList<CodeSnip>::const_iterator it = mod.snips.constBegin();
-            for (;it != mod.snips.constEnd(); ++it) {
-                if ((it->language & language) && (it->position == position || position == TypeSystem::CodeSnipPositionAny))
-                    result << *it;
+            for (const CodeSnip &snip : mod.snips) {
+                if ((snip.language & language) && (snip.position == position || position == TypeSystem::CodeSnipPositionAny))
+                    result << snip;
             }
         }
     }
@@ -974,10 +974,11 @@ CodeSnipList AbstractMetaFunction::injectedCodeSnips(TypeSystem::CodeSnipPositio
 
 bool AbstractMetaFunction::hasSignatureModifications() const
 {
-    foreach (const FunctionModification &mod, modifications()) {
+    const FunctionModificationList &mods = modifications();
+    for (const FunctionModification &mod : mods) {
         if (mod.isRenameModifier())
             return true;
-        foreach (const ArgumentModification &argmod, mod.argument_mods) {
+        for (const ArgumentModification &argmod : mod.argument_mods) {
             // since zero represents the return type and we're
             // interested only in checking the function arguments,
             // it will be ignored.
@@ -1133,8 +1134,8 @@ bool AbstractMetaFunction::isVirtual() const
 QString AbstractMetaFunction::modifiedName() const
 {
     if (m_cachedModifiedName.isEmpty()) {
-        FunctionModificationList mods = modifications(implementingClass());
-        foreach (const FunctionModification &mod, mods) {
+        const FunctionModificationList &mods = modifications(implementingClass());
+        for (const FunctionModification &mod : mods) {
             if (mod.isRenameModifier()) {
                 m_cachedModifiedName = mod.renamedToName;
                 break;
@@ -1261,10 +1262,8 @@ AbstractMetaClass::~AbstractMetaClass()
     qDeleteAll(m_functions);
     qDeleteAll(m_fields);
     qDeleteAll(m_enums);
-    if (hasTemplateBaseClassInstantiations()) {
-        foreach (AbstractMetaType* inst, templateBaseClassInstantiations())
-            delete inst;
-    }
+    if (hasTemplateBaseClassInstantiations())
+        qDeleteAll(templateBaseClassInstantiations());
 }
 
 /*******************************************************************************
@@ -1300,7 +1299,7 @@ AbstractMetaClass *AbstractMetaClass::extractInterface()
 
         iface->setTypeEntry(typeEntry()->designatedInterface());
 
-        foreach (AbstractMetaFunction *function, functions()) {
+        for (AbstractMetaFunction *function : qAsConst(m_functions)) {
             if (!function->isConstructor())
                 iface->addFunction(function->copy());
         }
@@ -1308,7 +1307,7 @@ AbstractMetaClass *AbstractMetaClass::extractInterface()
 //         iface->setEnums(enums());
 //         setEnums(AbstractMetaEnumList());
 
-        foreach (const AbstractMetaField *field, fields()) {
+        for (const AbstractMetaField *field : qAsConst(m_fields)) {
             if (field->isPublic()) {
                 AbstractMetaField *new_field = field->copy();
                 new_field->setEnclosingClass(iface);
@@ -1329,8 +1328,7 @@ AbstractMetaClass *AbstractMetaClass::extractInterface()
 AbstractMetaFunctionList AbstractMetaClass::queryFunctionsByName(const QString &name) const
 {
     AbstractMetaFunctionList returned;
-    AbstractMetaFunctionList functions = this->functions();
-    foreach (AbstractMetaFunction *function, functions) {
+    for (AbstractMetaFunction *function : m_functions) {
         if (function->name() == name)
             returned.append(function);
     }
@@ -1376,10 +1374,10 @@ AbstractMetaFunctionList AbstractMetaClass::functionsInTargetLang() const
 
 AbstractMetaFunctionList AbstractMetaClass::virtualFunctions() const
 {
-    AbstractMetaFunctionList list = functionsInShellClass();
+    const AbstractMetaFunctionList &list = functionsInShellClass();
 
     AbstractMetaFunctionList returned;
-    foreach (AbstractMetaFunction *f, list) {
+    for (AbstractMetaFunction *f : list) {
         if (!f->isFinalInCpp() || f->isVirtualSlot())
             returned += f;
     }
@@ -1393,14 +1391,12 @@ AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const
         return AbstractMetaFunctionList();
 
     AbstractMetaFunctionList returned;
-    AbstractMetaFunctionList list = queryFunctions(Constructors);
-
-    list.append(externalConversionOperators());
+    const AbstractMetaFunctionList list = queryFunctions(Constructors) + externalConversionOperators();
 
     // Exclude anything that uses rvalue references, be it a move
     // constructor "QPolygon(QPolygon &&)" or something else like
     // "QPolygon(QVector<QPoint> &&)".
-    foreach (AbstractMetaFunction *f, list) {
+    for (AbstractMetaFunction *f : list) {
         if ((f->actualMinimumArgumentCount() == 1 || f->arguments().size() == 1 || f->isConversionOperator())
             && !f->isExplicit()
             && f->functionType() != AbstractMetaFunction::CopyConstructorFunction
@@ -1415,9 +1411,9 @@ AbstractMetaFunctionList AbstractMetaClass::implicitConversions() const
 
 AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptions query) const
 {
-    AbstractMetaFunctionList list = queryFunctions(OperatorOverloads | Visible);
+    const AbstractMetaFunctionList &list = queryFunctions(OperatorOverloads | Visible);
     AbstractMetaFunctionList returned;
-    foreach (AbstractMetaFunction *f, list) {
+    for (AbstractMetaFunction *f : list) {
         if (((query & ArithmeticOp) && f->isArithmeticOperator())
             || ((query & BitwiseOp) && f->isBitwiseOperator())
             || ((query & ComparisonOp) && f->isComparisonOperator())
@@ -1434,7 +1430,7 @@ AbstractMetaFunctionList AbstractMetaClass::operatorOverloads(OperatorQueryOptio
 
 bool AbstractMetaClass::hasOperatorOverload() const
 {
-    foreach (const AbstractMetaFunction *f, m_functions) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isOperatorOverload() && !f->isPrivate())
             return true;
     }
@@ -1443,7 +1439,7 @@ bool AbstractMetaClass::hasOperatorOverload() const
 
 bool AbstractMetaClass::hasArithmeticOperatorOverload() const
 {
-    foreach (const AbstractMetaFunction *f, m_functions) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isArithmeticOperator() && !f->isPrivate())
             return true;
     }
@@ -1452,7 +1448,7 @@ bool AbstractMetaClass::hasArithmeticOperatorOverload() const
 
 bool AbstractMetaClass::hasBitwiseOperatorOverload() const
 {
-    foreach (const AbstractMetaFunction *f, m_functions) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isBitwiseOperator() && !f->isPrivate())
             return true;
     }
@@ -1461,7 +1457,7 @@ bool AbstractMetaClass::hasBitwiseOperatorOverload() const
 
 bool AbstractMetaClass::hasComparisonOperatorOverload() const
 {
-    foreach (const AbstractMetaFunction *f, m_functions) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isComparisonOperator() && !f->isPrivate())
             return true;
     }
@@ -1470,7 +1466,7 @@ bool AbstractMetaClass::hasComparisonOperatorOverload() const
 
 bool AbstractMetaClass::hasLogicalOperatorOverload() const
 {
-    foreach (const AbstractMetaFunction *f, m_functions) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isLogicalOperator() && !f->isPrivate())
             return true;
     }
@@ -1479,7 +1475,7 @@ bool AbstractMetaClass::hasLogicalOperatorOverload() const
 
 bool AbstractMetaClass::hasSubscriptOperatorOverload() const
 {
-    foreach (const AbstractMetaFunction *f, m_functions) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isSubscriptOperator() && !f->isPrivate())
             return true;
     }
@@ -1488,7 +1484,7 @@ bool AbstractMetaClass::hasSubscriptOperatorOverload() const
 
 bool AbstractMetaClass::hasAssignmentOperatorOverload() const
 {
-    foreach (const AbstractMetaFunction *f, m_functions) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isAssignmentOperator() && !f->isPrivate())
             return true;
     }
@@ -1497,7 +1493,7 @@ bool AbstractMetaClass::hasAssignmentOperatorOverload() const
 
 bool AbstractMetaClass::hasConversionOperatorOverload() const
 {
-    foreach (const AbstractMetaFunction *f, m_functions) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->ownerClass() == f->implementingClass() && f->isConversionOperator() && !f->isPrivate())
             return true;
     }
@@ -1558,7 +1554,7 @@ void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
     QString currentName;
     bool hasVirtuals = false;
     AbstractMetaFunctionList finalFunctions;
-    foreach (AbstractMetaFunction *f, m_functions) {
+    for (AbstractMetaFunction *f : qAsConst(m_functions)) {
         f->setOwnerClass(this);
 
         m_hasVirtualSlots = m_hasVirtualSlots || f->isVirtualSlot();
@@ -1574,7 +1570,7 @@ void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
                 finalFunctions += f;
         } else {
             if (hasVirtuals && finalFunctions.size() > 0) {
-                foreach (AbstractMetaFunction *final_function, finalFunctions) {
+                for (AbstractMetaFunction *final_function : qAsConst(finalFunctions)) {
                     *final_function += AbstractMetaAttributes::ForceShellImplementation;
 
                     qCWarning(lcShiboken).noquote().nospace()
@@ -1594,7 +1590,7 @@ void AbstractMetaClass::setFunctions(const AbstractMetaFunctionList &functions)
 
 bool AbstractMetaClass::hasFieldAccessors() const
 {
-    foreach (const AbstractMetaField *field, fields()) {
+    for (const AbstractMetaField *field : m_fields) {
         if (field->getter() || field->setter())
             return true;
     }
@@ -1604,7 +1600,8 @@ bool AbstractMetaClass::hasFieldAccessors() const
 
 bool AbstractMetaClass::hasDefaultToStringFunction() const
 {
-    foreach (AbstractMetaFunction *f, queryFunctionsByName(QLatin1String("toString"))) {
+    const AbstractMetaFunctionList &funcs = queryFunctionsByName(QLatin1String("toString"));
+    for (const AbstractMetaFunction *f : funcs) {
         if (!f->actualMinimumArgumentCount())
             return true;
     }
@@ -1632,7 +1629,7 @@ bool AbstractMetaClass::hasSignal(const AbstractMetaFunction *other) const
     if (!other->isSignal())
         return false;
 
-    foreach (const AbstractMetaFunction *f, functions()) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->isSignal() && f->compareTo(other) & AbstractMetaFunction::EqualName)
             return other->modifiedName() == f->modifiedName();
     }
@@ -1685,7 +1682,7 @@ bool AbstractMetaClass::hasFunction(const QString &str) const
 
 const AbstractMetaFunction* AbstractMetaClass::findFunction(const QString& functionName) const
 {
-    foreach (const AbstractMetaFunction *f, functions()) {
+    for (const AbstractMetaFunction *f : m_functions) {
         if (f->name() == functionName)
             return f;
     }
@@ -1694,7 +1691,7 @@ const AbstractMetaFunction* AbstractMetaClass::findFunction(const QString& funct
 
 bool AbstractMetaClass::hasProtectedFunctions() const
 {
-    foreach (AbstractMetaFunction *func, m_functions) {
+    for (AbstractMetaFunction *func : m_functions) {
         if (func->isProtected())
             return true;
     }
@@ -1703,7 +1700,7 @@ bool AbstractMetaClass::hasProtectedFunctions() const
 
 bool AbstractMetaClass::hasProtectedFields() const
 {
-    foreach (const AbstractMetaField *field, fields()) {
+    for (const AbstractMetaField *field : m_fields) {
         if (field->isProtected())
             return true;
     }
@@ -1775,7 +1772,7 @@ void AbstractMetaClass::setTemplateBaseClassInstantiations(AbstractMetaTypeList&
 
 static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func)
 {
-    foreach (const AbstractMetaFunction *f, l) {
+    for (const AbstractMetaFunction *f : l) {
         if ((f->compareTo(func) & AbstractMetaFunction::PrettySimilar) == AbstractMetaFunction::PrettySimilar)
             return true;
     }
@@ -1809,8 +1806,8 @@ AbstractMetaField *AbstractMetaField::copy() const
  */
 bool AbstractMetaField::isModifiedRemoved(int types) const
 {
-    FieldModificationList mods = modifications();
-    foreach (const FieldModification &mod, mods) {
+    const FieldModificationList &mods = modifications();
+    for (const FieldModification &mod : mods) {
         if (!mod.isRemoveModifier())
             continue;
 
@@ -1854,8 +1851,8 @@ static AbstractMetaFunction *createXetter(const AbstractMetaField *g, const QStr
     f->setAttributes(attr);
     f->setOriginalAttributes(attr);
 
-    FieldModificationList mods = g->modifications();
-    foreach (const FieldModification &mod, mods) {
+    const FieldModificationList &mods = g->modifications();
+    for (const FieldModification &mod : mods) {
         if (mod.isRenameModifier())
             f->setName(mod.renamedTo());
         if (mod.isAccessModifier()) {
@@ -1874,10 +1871,10 @@ static AbstractMetaFunction *createXetter(const AbstractMetaField *g, const QStr
 
 FieldModificationList AbstractMetaField::modifications() const
 {
-    FieldModificationList mods = enclosingClass()->typeEntry()->fieldModifications();
+    const FieldModificationList &mods = enclosingClass()->typeEntry()->fieldModifications();
     FieldModificationList returned;
 
-    foreach (const FieldModification &mod, mods) {
+    for (const FieldModification &mod : mods) {
         if (mod.name == name())
             returned += mod;
     }
@@ -1994,7 +1991,8 @@ bool AbstractMetaClass::hasConstructors() const
 
 bool AbstractMetaClass::hasCopyConstructor() const
 {
-    foreach (const AbstractMetaFunction* ctor, queryFunctions(Constructors)) {
+    const AbstractMetaFunctionList &ctors = queryFunctions(Constructors);
+    for (const AbstractMetaFunction* ctor : ctors) {
         if (ctor->functionType() == AbstractMetaFunction::CopyConstructorFunction)
             return true;
     }
@@ -2003,7 +2001,8 @@ bool AbstractMetaClass::hasCopyConstructor() const
 
 bool AbstractMetaClass::hasPrivateCopyConstructor() const
 {
-    foreach (const AbstractMetaFunction* ctor, queryFunctions(Constructors)) {
+    const AbstractMetaFunctionList &ctors = queryFunctions(Constructors);
+    for (const AbstractMetaFunction *ctor : ctors) {
         if (ctor->functionType() == AbstractMetaFunction::CopyConstructorFunction && ctor->isPrivate())
             return true;
     }
@@ -2077,7 +2076,7 @@ AbstractMetaFunctionList AbstractMetaClass::queryFunctions(FunctionQueryOptions
 {
     AbstractMetaFunctionList functions;
 
-    foreach (AbstractMetaFunction *f, m_functions) {
+    for (AbstractMetaFunction *f : m_functions) {
 
         if ((query & VirtualSlots) && !f->isVirtualSlot())
             continue;
@@ -2199,8 +2198,10 @@ void AbstractMetaClass::addInterface(AbstractMetaClass *interface)
     if (m_extractedInterface && m_extractedInterface != interface)
         m_extractedInterface->addInterface(interface);
 
+
 #if 0
-    foreach (AbstractMetaFunction *function, interface->functions())
+    const AbstractMetaFunctionList &funcs = interface->functions();
+    for (AbstractMetaFunction *function : funcs)
     if (!hasFunction(function) && !function->isConstructor()) {
         AbstractMetaFunction *cpy = function->copy();
         cpy->setImplementingClass(this);
@@ -2210,8 +2211,8 @@ void AbstractMetaClass::addInterface(AbstractMetaClass *interface)
         *cpy += AbstractMetaAttributes::InterfaceFunction;
 
         // Copy the modifications in interface into the implementing classes.
-        FunctionModificationList mods = function->modifications(interface);
-        foreach (const FunctionModification &mod, mods)
+        const FunctionModificationList &mods = function->modifications(interface);
+        for (const FunctionModification &mod : mods)
             m_typeEntry->addFunctionModification(mod);
 
         // It should be mostly safe to assume that when we implement an interface
@@ -2228,7 +2229,7 @@ void AbstractMetaClass::addInterface(AbstractMetaClass *interface)
 void AbstractMetaClass::setInterfaces(const AbstractMetaClassList &interfaces)
 {
     m_interfaces = interfaces;
-    foreach (const AbstractMetaClass* interface, interfaces) {
+    for (const AbstractMetaClass *interface : interfaces) {
         if (interface)
             m_isPolymorphic |= interface->isPolymorphic();
     }
@@ -2237,7 +2238,7 @@ void AbstractMetaClass::setInterfaces(const AbstractMetaClassList &interfaces)
 
 AbstractMetaEnum *AbstractMetaClass::findEnum(const QString &enumName)
 {
-    foreach (AbstractMetaEnum *e, m_enums) {
+    for (AbstractMetaEnum *e : qAsConst(m_enums)) {
         if (e->name() == enumName)
             return e;
     }
@@ -2257,10 +2258,11 @@ AbstractMetaEnum *AbstractMetaClass::findEnum(const QString &enumName)
 */
 AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const QString &enumValueName, AbstractMetaEnum *meta_enum)
 {
-    foreach (AbstractMetaEnum *e, m_enums) {
+    for (AbstractMetaEnum *e : qAsConst(m_enums)) {
         if (e != meta_enum)
             continue;
-        foreach (AbstractMetaEnumValue *v, e->values()) {
+        const AbstractMetaEnumValueList &values = e->values();
+        for (AbstractMetaEnumValue *v : values) {
             if (v->name() == enumValueName)
                 return v;
         }
@@ -2284,8 +2286,9 @@ AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const QString &enumValue
  */
 AbstractMetaEnum *AbstractMetaClass::findEnumForValue(const QString &enumValueName)
 {
-    foreach (AbstractMetaEnum *e, m_enums) {
-        foreach (AbstractMetaEnumValue *v, e->values()) {
+    for (AbstractMetaEnum *e : qAsConst(m_enums)) {
+        const AbstractMetaEnumValueList &values = e->values();
+        for (AbstractMetaEnumValue *v : values) {
             if (v->name() == enumValueName)
                 return e;
         }
@@ -2316,8 +2319,8 @@ static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractM
     }
 
     if (type->hasInstantiations()) {
-        AbstractMetaTypeList instantiations = type->instantiations();
-        foreach (const AbstractMetaType *instantiation, instantiations)
+        const AbstractMetaTypeList &instantiations = type->instantiations();
+        for (const AbstractMetaType *instantiation : instantiations)
             addExtraIncludeForType(metaClass, instantiation);
     }
 }
@@ -2328,9 +2331,9 @@ static void addExtraIncludesForFunction(AbstractMetaClass *metaClass, const Abst
     Q_ASSERT(meta_function);
     addExtraIncludeForType(metaClass, meta_function->type());
 
-    AbstractMetaArgumentList arguments = meta_function->arguments();
-    foreach (AbstractMetaArgument *argument, arguments)
-    addExtraIncludeForType(metaClass, argument->type());
+    const AbstractMetaArgumentList &arguments = meta_function->arguments();
+    for (AbstractMetaArgument *argument : arguments)
+        addExtraIncludeForType(metaClass, argument->type());
 }
 
 void AbstractMetaClass::fixFunctions()
@@ -2448,8 +2451,8 @@ void AbstractMetaClass::fixFunctions()
 
                                 bool hasNonFinalModifier = false;
                                 bool isBaseImplPrivate = false;
-                                FunctionModificationList mods = sf->modifications(sf->implementingClass());
-                                foreach (const FunctionModification &mod, mods) {
+                                const FunctionModificationList &mods = sf->modifications(sf->implementingClass());
+                                for (const FunctionModification &mod : mods) {
                                     if (mod.isNonFinal()) {
                                         hasNonFinalModifier = true;
                                         break;
@@ -2495,7 +2498,7 @@ void AbstractMetaClass::fixFunctions()
                 funcsToAdd << sf;
         }
 
-        foreach (AbstractMetaFunction *f, funcsToAdd)
+        for (AbstractMetaFunction *f : qAsConst(funcsToAdd))
             funcs << f->copy();
 
         if (superClass)
@@ -2506,9 +2509,9 @@ void AbstractMetaClass::fixFunctions()
 
     bool hasPrivateConstructors = false;
     bool hasPublicConstructors = false;
-    foreach (AbstractMetaFunction *func, funcs) {
-        FunctionModificationList mods = func->modifications(this);
-        foreach (const FunctionModification &mod, mods) {
+    for (AbstractMetaFunction *func : qAsConst(funcs)) {
+        const FunctionModificationList &mods = func->modifications(this);
+        for (const FunctionModification &mod : mods) {
             if (mod.isRenameModifier()) {
                 func->setName(mod.renamedTo());
             }
@@ -2540,8 +2543,8 @@ void AbstractMetaClass::fixFunctions()
         (*this) -= AbstractMetaAttributes::Final;
     }
 
-    foreach (AbstractMetaFunction *f1, funcs) {
-        foreach (AbstractMetaFunction *f2, funcs) {
+    for (AbstractMetaFunction *f1 : qAsConst(funcs)) {
+        for (AbstractMetaFunction *f2 : qAsConst(funcs)) {
             if (f1 != f2) {
                 const AbstractMetaFunction::CompareResult cmp = f1->compareTo(f2);
                 if ((cmp & AbstractMetaFunction::EqualName)
@@ -2664,8 +2667,9 @@ AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const AbstractMetaClassL
             return cl->findEnumValue(enumName, 0);
     }
 
-    foreach (AbstractMetaClass* metaClass, classes) {
-        foreach(AbstractMetaEnum* metaEnum, metaClass->enums()) {
+    for (AbstractMetaClass *metaClass : classes) {
+        const AbstractMetaEnumList &enums = metaClass->enums();
+        for (AbstractMetaEnum *metaEnum : enums) {
             AbstractMetaEnumValue* enumValue = metaClass->findEnumValue(name, metaEnum);
             if (enumValue)
                 return enumValue;
@@ -2688,17 +2692,17 @@ AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &cla
     if (name.isEmpty())
         return 0;
 
-    foreach (AbstractMetaClass *c, classes) {
+    for (AbstractMetaClass *c : classes) {
         if (c->qualifiedCppName() == name)
             return c;
     }
 
-    foreach (AbstractMetaClass *c, classes) {
+    for (AbstractMetaClass *c : classes) {
         if (c->fullName() == name)
             return c;
     }
 
-    foreach (AbstractMetaClass *c, classes) {
+    for (AbstractMetaClass *c : classes) {
         if (c->name() == name)
             return c;
     }
@@ -2709,7 +2713,7 @@ AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &cla
 AbstractMetaClass *AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
                                                 const TypeEntry* typeEntry)
 {
-    foreach (AbstractMetaClass* c, classes) {
+    for (AbstractMetaClass* c : classes) {
         if (c->typeEntry() == typeEntry)
             return c;
     }
diff --git a/ApiExtractor/abstractmetalang.h b/ApiExtractor/abstractmetalang.h
index 26702d3..0d03d2f 100644
--- a/ApiExtractor/abstractmetalang.h
+++ b/ApiExtractor/abstractmetalang.h
@@ -956,7 +956,7 @@ public:
     // true if one or more of the arguments are of QtJambiObject subclasses
     bool argumentsHaveNativeId() const
     {
-        foreach (const AbstractMetaArgument *arg, m_arguments) {
+        for (const AbstractMetaArgument *arg : m_arguments) {
             if (arg->type()->hasNativeId())
                 return true;
         }
diff --git a/ApiExtractor/apiextractor.cpp b/ApiExtractor/apiextractor.cpp
index 6fe534f..a83136e 100644
--- a/ApiExtractor/apiextractor.cpp
+++ b/ApiExtractor/apiextractor.cpp
@@ -75,7 +75,7 @@ void ApiExtractor::addTypesystemSearchPath (const QString& path)
 
 void ApiExtractor::addTypesystemSearchPath(const QStringList& paths)
 {
-    foreach (const QString &path, paths)
+    for (const QString &path : paths)
         addTypesystemSearchPath(path);
 }
 
@@ -180,8 +180,9 @@ QSet<QString> ApiExtractor::qtMetaTypeDeclaredTypeNames() const
 static const AbstractMetaEnum* findEnumOnClasses(AbstractMetaClassList metaClasses, const EnumTypeEntry* typeEntry)
 {
     const AbstractMetaEnum* result = 0;
-    foreach (const AbstractMetaClass* metaClass, metaClasses) {
-        foreach (const AbstractMetaEnum* metaEnum, metaClass->enums()) {
+    for (const AbstractMetaClass* metaClass : qAsConst(metaClasses)) {
+        const AbstractMetaEnumList &enums = metaClass->enums();
+        for (const AbstractMetaEnum *metaEnum : enums) {
             if (metaEnum->typeEntry() == typeEntry) {
                 result = metaEnum;
                 break;
@@ -198,7 +199,8 @@ const AbstractMetaEnum* ApiExtractor::findAbstractMetaEnum(const EnumTypeEntry*
 {
     if (!typeEntry)
         return 0;
-    foreach (AbstractMetaEnum* metaEnum, m_builder->globalEnums()) {
+    const AbstractMetaEnumList &globalEnums = m_builder->globalEnums();
+    for (AbstractMetaEnum* metaEnum : globalEnums) {
         if (metaEnum->typeEntry() == typeEntry)
             return metaEnum;
     }
@@ -269,7 +271,7 @@ bool ApiExtractor::run()
     m_builder->setGlobalHeader(m_cppFileName);
     QByteArrayList arguments;
     arguments.reserve(m_includePaths.size() + 1);
-    foreach (const QString &i, m_includePaths)
+    for (const QString &i : qAsConst(m_includePaths))
         arguments.append(QByteArrayLiteral("-I") + QFile::encodeName(i));
     arguments.append(QFile::encodeName(preprocessedCppFileName));
     qCDebug(lcShiboken) << __FUNCTION__ << arguments;
diff --git a/ApiExtractor/docparser.cpp b/ApiExtractor/docparser.cpp
index 4ec1da2..bae438f 100644
--- a/ApiExtractor/docparser.cpp
+++ b/ApiExtractor/docparser.cpp
@@ -104,7 +104,7 @@ QString DocParser::applyDocModifications(const DocModificationList& mods, const
         return xml;
 
     bool hasXPathBasedModification = false;
-    foreach (DocModification mod, mods) {
+    for (const DocModification &mod : mods) {
         if (mod.mode() == TypeSystem::DocModificationXPathReplace) {
             hasXPathBasedModification = true;
             break;
@@ -126,7 +126,7 @@ QString DocParser::applyDocModifications(const DocModificationList& mods, const
                                 "</xsl:copy>\n"
                                 "</xsl:template>\n"
                                );
-    foreach (DocModification mod, mods) {
+    for (const DocModification &mod : mods) {
         if (mod.mode() == TypeSystem::DocModificationXPathReplace) {
             QString xpath = mod.xpath();
             xpath.replace(QLatin1Char('"'), QLatin1String("&quot;"));
diff --git a/ApiExtractor/doxygenparser.cpp b/ApiExtractor/doxygenparser.cpp
index f7d868f..6b90fe6 100644
--- a/ApiExtractor/doxygenparser.cpp
+++ b/ApiExtractor/doxygenparser.cpp
@@ -105,8 +105,8 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
     metaClass->setDocumentation(classDoc);
 
     //Functions Documentation
-    AbstractMetaFunctionList funcs = metaClass->functionsInTargetLang();
-    foreach (AbstractMetaFunction *func, funcs) {
+    const AbstractMetaFunctionList &funcs = metaClass->functionsInTargetLang();
+    for (AbstractMetaFunction *func : funcs) {
         if (!func || func->isPrivate())
             continue;
 
@@ -128,8 +128,8 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
                 query += QLatin1String("/../argsstring[text()=\"") + args + QLatin1String("\"]");
             } else {
                 int i = 1;
-                foreach (AbstractMetaArgument* arg, func->arguments()) {
-                    QString type;
+                const AbstractMetaArgumentList &arguments = func->arguments();
+                for (AbstractMetaArgument *arg : arguments) {
                     if (!arg->type()->isPrimitive()) {
                         query += QLatin1String("/../param[") + QString::number(i)
                                  + QLatin1String("]/type/ref[text()=\"")
@@ -155,8 +155,8 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
     }
 
     //Fields
-    AbstractMetaFieldList fields = metaClass->fields();
-    foreach (AbstractMetaField *field, fields) {
+    const AbstractMetaFieldList &fields = metaClass->fields();
+    for (AbstractMetaField *field : fields) {
         if (field->isPrivate())
             return;
 
@@ -167,8 +167,8 @@ void DoxygenParser::fillDocumentation(AbstractMetaClass* metaClass)
     }
 
     //Enums
-    AbstractMetaEnumList enums = metaClass->enums();
-    foreach (AbstractMetaEnum *meta_enum, enums) {
+    const AbstractMetaEnumList &enums = metaClass->enums();
+    for (AbstractMetaEnum *meta_enum : enums) {
         QString query = QLatin1String("/doxygen/compounddef/sectiondef/memberdef[@kind=\"enum\"]/name[text()=\"")
             + meta_enum->name() + QLatin1String("\"]/..");
         QString doc = getDocumentation(xquery, query, DocModificationList());
diff --git a/ApiExtractor/parser/codemodel.cpp b/ApiExtractor/parser/codemodel.cpp
index a5024c4..db37a79 100644
--- a/ApiExtractor/parser/codemodel.cpp
+++ b/ApiExtractor/parser/codemodel.cpp
@@ -221,7 +221,7 @@ QString TypeInfo::toString() const
         tmp += QLatin1Char(')');
     }
 
-    foreach(QString elt, arrayElements()) {
+    for (const QString &elt : m_arrayElements) {
         tmp += QLatin1Char('[');
         tmp += elt;
         tmp += QLatin1Char(']');
@@ -588,7 +588,7 @@ void _ClassModelItem::formatDebug(QDebug &d) const
 // ---------------------------------------------------------------------------
 FunctionModelItem _ScopeModelItem::declaredFunction(FunctionModelItem item)
 {
-    foreach (const FunctionModelItem &fun, m_functions) {
+    for (const FunctionModelItem &fun : qAsConst(m_functions)) {
         if (fun->name() == item->name() && fun->isSimilar(item))
             return fun;
 
@@ -730,7 +730,7 @@ EnumModelItem _ScopeModelItem::findEnum(const QString &name) const
 FunctionList _ScopeModelItem::findFunctions(const QString &name) const
 {
     FunctionList result;
-    foreach (const FunctionModelItem &func, m_functions) {
+    for (const FunctionModelItem &func : m_functions) {
         if (func->name() == name)
             result.append(func);
     }
diff --git a/ApiExtractor/qtdocparser.cpp b/ApiExtractor/qtdocparser.cpp
index f1421ff..00e2384 100644
--- a/ApiExtractor/qtdocparser.cpp
+++ b/ApiExtractor/qtdocparser.cpp
@@ -79,7 +79,8 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
                     + className + QLatin1String("\"]/description");
 
     DocModificationList signedModifs, classModifs;
-    foreach (DocModification docModif, metaClass->typeEntry()->docModifications()) {
+    const DocModificationList &mods = metaClass->typeEntry()->docModifications();
+    for (const DocModification &docModif : mods) {
         if (docModif.signature().isEmpty())
             classModifs.append(docModif);
         else
@@ -91,8 +92,8 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
 
 
     //Functions Documentation
-    AbstractMetaFunctionList funcs = metaClass->functionsInTargetLang();
-    foreach (AbstractMetaFunction *func, funcs) {
+    const AbstractMetaFunctionList &funcs = metaClass->functionsInTargetLang();
+    for (AbstractMetaFunction *func : funcs) {
         if (!func || func->isPrivate())
             continue;
 
@@ -109,8 +110,9 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
                      + QString::number(func->arguments().count())
                      + QLatin1String(" and @const=\"") + isConst + QLatin1String("\"]");
 
-            int i = 1;
-            foreach (AbstractMetaArgument* arg, func->arguments()) {
+            const AbstractMetaArgumentList &arguments = func->arguments();
+            for (int i = 0, size = arguments.size(); i < size; ++i) {
+                const AbstractMetaArgument *arg = arguments.at(i);
                 QString type = arg->type()->name();
 
                 if (arg->type()->isConstant())
@@ -125,14 +127,13 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
                     for (int j = 0, max = arg->type()->indirections(); j < max; ++j)
                         type += QLatin1Char('*');
                 }
-                query += QLatin1String("/parameter[") + QString::number(i)
+                query += QLatin1String("/parameter[") + QString::number(i + 1)
                          + QLatin1String("][@left=\"") + type + QLatin1String("\"]/..");
-                ++i;
             }
         }
         query += QLatin1String("/description");
         DocModificationList funcModifs;
-        foreach (DocModification funcModif, signedModifs) {
+        for (const DocModification &funcModif : qAsConst(signedModifs)) {
             if (funcModif.signature() == func->minimalSignature())
                 funcModifs.append(funcModif);
         }
@@ -141,8 +142,8 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
     }
 #if 0
     // Fields
-    AbstractMetaFieldList fields = metaClass->fields();
-    foreach (AbstractMetaField *field, fields) {
+    const AbstractMetaFieldList &fields = metaClass->fields();
+    for (AbstractMetaField *field : fields) {
         if (field->isPrivate())
             return;
 
@@ -152,8 +153,8 @@ void QtDocParser::fillDocumentation(AbstractMetaClass* metaClass)
     }
 #endif
     // Enums
-    AbstractMetaEnumList enums = metaClass->enums();
-    foreach (AbstractMetaEnum *meta_enum, enums) {
+    const AbstractMetaEnumList &enums = metaClass->enums();
+    for (AbstractMetaEnum *meta_enum : enums) {
         QString query = QLatin1String("/WebXML/document/") + type
                         + QLatin1String("[@name=\"")
                         + className + QLatin1String("\"]/enum[@name=\"")
diff --git a/ApiExtractor/tests/testaddfunction.cpp b/ApiExtractor/tests/testaddfunction.cpp
index 6e1da17..119d536 100644
--- a/ApiExtractor/tests/testaddfunction.cpp
+++ b/ApiExtractor/tests/testaddfunction.cpp
@@ -423,8 +423,8 @@ void TestAddFunction::testAddFunctionOnTypedef()
     AbstractMetaClass* foo = AbstractMetaClass::findClass(classes, QLatin1String("FooInt"));
     QVERIFY(foo);
     QVERIFY(foo->hasNonPrivateConstructor());
-    AbstractMetaFunctionList lst = foo->queryFunctions(AbstractMetaClass::Constructors);
-    foreach(AbstractMetaFunction* f, lst)
+    const AbstractMetaFunctionList &lst = foo->queryFunctions(AbstractMetaClass::Constructors);
+    for (const AbstractMetaFunction *f : lst)
         QVERIFY(f->signature().startsWith(f->name()));
     QCOMPARE(lst.size(), 2);
     const AbstractMetaFunction* method = foo->findFunction(QLatin1String("method"));
diff --git a/ApiExtractor/tests/testarrayargument.cpp b/ApiExtractor/tests/testarrayargument.cpp
index 5385c91..4d46d44 100644
--- a/ApiExtractor/tests/testarrayargument.cpp
+++ b/ApiExtractor/tests/testarrayargument.cpp
@@ -112,7 +112,8 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu
     AbstractMetaEnum* someEnum = builder->globalEnums().first();
     QVERIFY(someEnum);
     AbstractMetaEnumValue* nvalues = 0;
-    foreach (AbstractMetaEnumValue* enumValue, someEnum->values()) {
+    const AbstractMetaEnumValueList &values = someEnum->values();
+    for (AbstractMetaEnumValue *enumValue : values) {
         if (enumValue->name() == QLatin1String("NValues")) {
             nvalues = enumValue;
             break;
diff --git a/ApiExtractor/tests/testconversionoperator.cpp b/ApiExtractor/tests/testconversionoperator.cpp
index cae4a3a..86f5713 100644
--- a/ApiExtractor/tests/testconversionoperator.cpp
+++ b/ApiExtractor/tests/testconversionoperator.cpp
@@ -65,7 +65,7 @@ void TestConversionOperator::testConversionOperator()
     QCOMPARE(classA->externalConversionOperators().count(), 2);
 
     AbstractMetaFunction* convOp = 0;
-    foreach(AbstractMetaFunction* func, classB->functions()) {
+    for (AbstractMetaFunction *func : classB->functions()) {
         if (func->isConversionOperator()) {
             convOp = func;
             break;
diff --git a/ApiExtractor/tests/testimplicitconversions.cpp b/ApiExtractor/tests/testimplicitconversions.cpp
index 4438550..7e8db42 100644
--- a/ApiExtractor/tests/testimplicitconversions.cpp
+++ b/ApiExtractor/tests/testimplicitconversions.cpp
@@ -152,7 +152,7 @@ void TestImplicitConversions::testWithExternalConversionOperator()
     QCOMPARE(externalConvOps.count(), 1);
 
     const AbstractMetaFunction* convOp = 0;
-    foreach(const AbstractMetaFunction* func, classB->functions()) {
+    for (const AbstractMetaFunction *func : classB->functions()) {
         if (func->isConversionOperator())
             convOp = func;
     }
diff --git a/ApiExtractor/tests/testmultipleinheritance.cpp b/ApiExtractor/tests/testmultipleinheritance.cpp
index 67c9089..b78e6ec 100644
--- a/ApiExtractor/tests/testmultipleinheritance.cpp
+++ b/ApiExtractor/tests/testmultipleinheritance.cpp
@@ -61,7 +61,8 @@ void TestMultipleInheritance::testVirtualClass()
 
     const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("D"));
     bool functionFound = false;
-    foreach (AbstractMetaFunction* f, classD->functions()) {
+    const AbstractMetaFunctionList &functions = classD->functions();
+    for (AbstractMetaFunction *f : functions) {
         if (f->name() == QLatin1String("theBug")) {
             functionFound = true;
             break;
diff --git a/ApiExtractor/tests/testremoveoperatormethod.cpp b/ApiExtractor/tests/testremoveoperatormethod.cpp
index 6b27227..508cff5 100644
--- a/ApiExtractor/tests/testremoveoperatormethod.cpp
+++ b/ApiExtractor/tests/testremoveoperatormethod.cpp
@@ -105,7 +105,8 @@ void TestRemoveOperatorMethod::testRemoveOperatorMethod()
     removedSignatures.append(QLatin1String("operator>>(Char&)"));
     removedSignatures.append(QLatin1String("operator>>(String&)"));
     int notRemoved = classA->functions().size();
-    foreach (const AbstractMetaFunction* f, classA->functions()) {
+    const AbstractMetaFunctionList &functions = classA->functions();
+    for (const AbstractMetaFunction *f : functions) {
         QCOMPARE(f->isModifiedRemoved(), bool(removedSignatures.contains(f->minimalSignature())));
         notRemoved -= int(f->isModifiedRemoved());
     }
diff --git a/ApiExtractor/tests/testreverseoperators.cpp b/ApiExtractor/tests/testreverseoperators.cpp
index a99b214..18d6902 100644
--- a/ApiExtractor/tests/testreverseoperators.cpp
+++ b/ApiExtractor/tests/testreverseoperators.cpp
@@ -53,7 +53,7 @@ void TestReverseOperators::testReverseSum()
 
     const AbstractMetaFunction* reverseOp = 0;
     const AbstractMetaFunction* normalOp = 0;
-    foreach(const AbstractMetaFunction* func, classA->functions()) {
+    for (const AbstractMetaFunction *func : classA->functions()) {
         if (func->name() == QLatin1String("operator+")) {
             if (func->isReverseOperator())
                 reverseOp = func;
@@ -102,7 +102,7 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
 
     const AbstractMetaFunction* reverseOp = 0;
     const AbstractMetaFunction* normalOp = 0;
-    foreach(const AbstractMetaFunction* func, classB->functions()) {
+    for (const AbstractMetaFunction *func : classB->functions()) {
         if (func->name() == QLatin1String("operator+")) {
             if (func->isReverseOperator())
                 reverseOp = func;
diff --git a/ApiExtractor/typedatabase.cpp b/ApiExtractor/typedatabase.cpp
index 5cb2550..005f93d 100644
--- a/ApiExtractor/typedatabase.cpp
+++ b/ApiExtractor/typedatabase.cpp
@@ -175,8 +175,8 @@ FunctionTypeEntry* TypeDatabase::findFunctionType(const QString& name) const
 
 TypeEntry* TypeDatabase::findType(const QString& name) const
 {
-    QList<TypeEntry *> entries = findTypes(name);
-    foreach (TypeEntry *entry, entries) {
+    const QList<TypeEntry *> &entries = findTypes(name);
+    for (TypeEntry *entry : entries) {
         if (entry &&
             (!entry->isPrimitive() || static_cast<PrimitiveTypeEntry *>(entry)->preferredTargetLangType())) {
             return entry;
@@ -206,7 +206,7 @@ QList<const PrimitiveTypeEntry*> TypeDatabase::primitiveTypes() const
     TypeEntryHash entries = allEntries();
     QList<const PrimitiveTypeEntry*> returned;
     for (TypeEntryHash::const_iterator it = entries.cbegin(), end = entries.cend(); it != end; ++it) {
-        foreach (TypeEntry *typeEntry, it.value()) {
+        for (TypeEntry *typeEntry : it.value()) {
             if (typeEntry->isPrimitive())
                 returned.append(static_cast<PrimitiveTypeEntry *>(typeEntry));
         }
@@ -219,7 +219,7 @@ QList<const ContainerTypeEntry*> TypeDatabase::containerTypes() const
     TypeEntryHash entries = allEntries();
     QList<const ContainerTypeEntry*> returned;
     for (TypeEntryHash::const_iterator it = entries.cbegin(), end = entries.cend(); it != end; ++it) {
-        foreach (TypeEntry *typeEntry, it.value()) {
+        for (TypeEntry *typeEntry : it.value()) {
             if (typeEntry->isContainer())
                 returned.append(static_cast<ContainerTypeEntry *>(typeEntry));
         }
@@ -240,7 +240,7 @@ void TypeDatabase::addRejection(const QString& className, const QString& functio
 
 bool TypeDatabase::isClassRejected(const QString& className) const
 {
-    foreach (const TypeRejection& r, m_rejections) {
+    for (const TypeRejection& r : m_rejections) {
         if (r.class_name == className && r.function_name == QLatin1String("*")
             && r.field_name == QLatin1String("*") && r.enum_name == QLatin1String("*")) {
             return true;
@@ -251,7 +251,7 @@ bool TypeDatabase::isClassRejected(const QString& className) const
 
 bool TypeDatabase::isEnumRejected(const QString& className, const QString& enumName) const
 {
-    foreach (const TypeRejection& r, m_rejections) {
+    for (const TypeRejection& r : m_rejections) {
         if (r.enum_name == enumName
             && (r.class_name == className || r.class_name == QLatin1String("*"))) {
             return true;
@@ -268,20 +268,22 @@ void TypeDatabase::addType(TypeEntry *e)
 
 bool TypeDatabase::isFunctionRejected(const QString& className, const QString& functionName) const
 {
-    foreach (const TypeRejection& r, m_rejections)
+    for (const TypeRejection &r : m_rejections) {
     if (r.function_name == functionName &&
         (r.class_name == className || r.class_name == QLatin1String("*")))
         return true;
+    }
     return false;
 }
 
 
 bool TypeDatabase::isFieldRejected(const QString& className, const QString& fieldName) const
 {
-    foreach (const TypeRejection& r, m_rejections)
+    for (const TypeRejection &r : m_rejections) {
     if (r.field_name == fieldName &&
         (r.class_name == className || r.class_name == QLatin1String("*")))
         return true;
+    }
     return false;
 }
 
@@ -321,7 +323,7 @@ void TypeDatabase::addGlobalUserFunctions(const AddedFunctionList &functions)
 AddedFunctionList TypeDatabase::findGlobalUserFunctions(const QString& name) const
 {
     AddedFunctionList addedFunctions;
-    foreach (const AddedFunction &func, m_globalUserFunctions) {
+    for (const AddedFunction &func : m_globalUserFunctions) {
         if (func.name() == name)
             addedFunctions.append(func);
     }
@@ -360,8 +362,7 @@ bool TypeDatabase::isSuppressedWarning(const QString& s) const
     if (!m_suppressWarnings)
         return false;
 
-    foreach (const QString &_warning, m_suppressedWarnings) {
-        QString warning = _warning;
+    for (QString warning : m_suppressedWarnings) {
         warning.replace(QLatin1String("\\*"), QLatin1String("&place_holder_for_asterisk;"));
 
         QStringList segs = warning.split(QLatin1Char('*'), QString::SkipEmptyParts);
@@ -386,7 +387,7 @@ QString TypeDatabase::modifiedTypesystemFilepath(const QString& tsFile) const
     if (!QFile::exists(tsFile)) {
         int idx = tsFile.lastIndexOf(QLatin1Char('/'));
         QString fileName = idx >= 0 ? tsFile.right(tsFile.length() - idx - 1) : tsFile;
-        foreach (const QString &path, m_typesystemPaths) {
+        for (const QString &path : m_typesystemPaths) {
             QString filepath(path + QLatin1Char('/') + fileName);
             if (QFile::exists(filepath))
                 return filepath;
@@ -434,9 +435,9 @@ bool TypeDatabase::parseFile(QIODevice* device, bool generate)
 
 PrimitiveTypeEntry *TypeDatabase::findPrimitiveType(const QString& name) const
 {
-    QList<TypeEntry*> entries = findTypes(name);
+    const QList<TypeEntry *> &entries = findTypes(name);
 
-    foreach (TypeEntry* entry, entries) {
+    for (TypeEntry *entry : entries) {
         if (entry && entry->isPrimitive() && static_cast<PrimitiveTypeEntry*>(entry)->preferredTargetLangType())
             return static_cast<PrimitiveTypeEntry*>(entry);
     }
@@ -446,8 +447,8 @@ PrimitiveTypeEntry *TypeDatabase::findPrimitiveType(const QString& name) const
 
 ComplexTypeEntry* TypeDatabase::findComplexType(const QString& name) const
 {
-    QList<TypeEntry*> entries = findTypes(name);
-    foreach (TypeEntry* entry, entries) {
+    const QList<TypeEntry *> &entries = findTypes(name);
+    for (TypeEntry *entry : entries) {
         if (entry && entry->isComplex())
             return static_cast<ComplexTypeEntry*>(entry);
     }
@@ -456,8 +457,8 @@ ComplexTypeEntry* TypeDatabase::findComplexType(const QString& name) const
 
 ObjectTypeEntry* TypeDatabase::findObjectType(const QString& name) const
 {
-    QList<TypeEntry*> entries = findTypes(name);
-    foreach (TypeEntry* entry, entries) {
+    const QList<TypeEntry*> &entries = findTypes(name);
+    for (TypeEntry *entry : entries) {
         if (entry && entry->isObject())
             return static_cast<ObjectTypeEntry*>(entry);
     }
@@ -466,8 +467,8 @@ ObjectTypeEntry* TypeDatabase::findObjectType(const QString& name) const
 
 NamespaceTypeEntry* TypeDatabase::findNamespaceType(const QString& name) const
 {
-    QList<TypeEntry*> entries = findTypes(name);
-    foreach (TypeEntry* entry, entries) {
+    const QList<TypeEntry *> &entries = findTypes(name);
+    for (TypeEntry *entry : entries) {
         if (entry && entry->isNamespace())
             return static_cast<NamespaceTypeEntry*>(entry);
     }
@@ -516,9 +517,9 @@ static void _computeTypeIndexes()
     GroupedTypeEntries groupedEntries;
 
     // Group type entries by revision numbers
-    TypeEntryHash allEntries = tdb->allEntries();
-    foreach (QList<TypeEntry*> entryList, allEntries) {
-        foreach (TypeEntry* entry, entryList) {
+    const TypeEntryHash &allEntries = tdb->allEntries();
+    for (TypeEntryHash::const_iterator tit = allEntries.cbegin(), end = allEntries.cend(); tit != end; ++tit) {
+        for (TypeEntry *entry : tit.value()) {
             if (entry->isPrimitive()
                 || entry->isContainer()
                 || entry->isFunction()
@@ -542,7 +543,7 @@ static void _computeTypeIndexes()
         // Sort the type entries by name
         qSort(it.value().begin(), newEnd, compareTypeEntriesByName);
 
-        foreach (TypeEntry* entry, it.value()) {
+        for (TypeEntry *entry : qAsConst(it.value())) {
             (*typeEntryFields())[entry].second = maxTypeIndex++;
         }
     }
diff --git a/ApiExtractor/typeparser.cpp b/ApiExtractor/typeparser.cpp
index 67120a1..8165bfe 100644
--- a/ApiExtractor/typeparser.cpp
+++ b/ApiExtractor/typeparser.cpp
@@ -286,7 +286,7 @@ QString TypeParser::Info::instantiationName() const
     QString s(qualified_name.join(QLatin1String("::")));
     if (!template_instantiations.isEmpty()) {
         QStringList insts;
-        foreach (const Info &info, template_instantiations)
+        for (const Info &info : template_instantiations)
             insts << info.toString();
         s += QLatin1String("< ") + insts.join(QLatin1String(", ")) + QLatin1String(" >");
     }
diff --git a/ApiExtractor/typesystem.cpp b/ApiExtractor/typesystem.cpp
index 869904d..d33ae3f 100644
--- a/ApiExtractor/typesystem.cpp
+++ b/ApiExtractor/typesystem.cpp
@@ -209,8 +209,9 @@ bool Handler::endElement(const QStringRef &localName)
         if (m_generate == TypeEntry::GenerateAll) {
             TypeDatabase::instance()->addGlobalUserFunctions(m_contextStack.top()->addedFunctions);
             TypeDatabase::instance()->addGlobalUserFunctionModifications(m_contextStack.top()->functionMods);
-            foreach (CustomConversion* customConversion, customConversionsForReview) {
-                foreach (CustomConversion::TargetToNativeConversion* toNative, customConversion->targetToNativeConversions())
+            for (CustomConversion *customConversion : qAsConst(customConversionsForReview)) {
+                const CustomConversion::TargetToNativeConversions &toNatives = customConversion->targetToNativeConversions();
+                for (CustomConversion::TargetToNativeConversion *toNative : toNatives)
                     toNative->setSourceType(m_database->findType(toNative->sourceTypeName()));
             }
         }
@@ -850,7 +851,8 @@ bool Handler::startElement(const QStringRef &n, const QXmlStreamAttributes &atts
             // put in the flags parallel...
             const QString flagNames = attributes.value(flagsAttribute());
             if (!flagNames.isEmpty()) {
-                foreach (const QString &flagName, flagNames.split(QLatin1Char(',')))
+                const QStringList &flagNameList = flagNames.split(QLatin1Char(','));
+                for (const QString &flagName : flagNameList)
                     addFlags(name, flagName.trimmed(), attributes, since);
             }
         }
@@ -1746,8 +1748,8 @@ bool Handler::startElement(const QStringRef &n, const QXmlStreamAttributes &atts
 
             if (rc.action == ReferenceCount::Invalid) {
                 m_error = QLatin1String("unrecognized value for action attribute. supported actions:");
-                foreach (const QString &action, actions.keys())
-                    m_error += QLatin1Char(' ') + action;
+                for (QHash<QString, ReferenceCount::Action>::const_iterator it = actions.cbegin(), end = actions.cend(); it != end; ++it)
+                    m_error += QLatin1Char(' ') + it.key();
             }
 
             m_contextStack.top()->functionMods.last().argument_mods.last().referenceCounts.append(rc);
@@ -2172,7 +2174,7 @@ QString TemplateInstance::expandCode() const
 QString CodeSnipAbstract::code() const
 {
     QString res;
-    foreach (const CodeSnipFragment &codeFrag, codeList)
+    for (const CodeSnipFragment &codeFrag : codeList)
         res.append(codeFrag.code());
 
     return res;
@@ -2205,7 +2207,7 @@ QString FunctionModification::toString() const
     if (modifiers & Writable) str += QLatin1String("writable");
 
     if (modifiers & CodeInjection) {
-        foreach (const CodeSnip &s, snips) {
+        for (const CodeSnip &s : snips) {
             str += QLatin1String("\n//code injection:\n");
             str += s.code();
         }
@@ -2563,9 +2565,7 @@ CustomConversion::CustomConversion(TypeEntry* ownerType)
 
 CustomConversion::~CustomConversion()
 {
-    foreach (TargetToNativeConversion* targetToNativeConversion, m_d->targetToNativeConversions)
-        delete targetToNativeConversion;
-    m_d->targetToNativeConversions.clear();
+    qDeleteAll(m_d->targetToNativeConversions);
     delete m_d;
 }
 
diff --git a/generator/generator.cpp b/generator/generator.cpp
index d7f98a9..69e9713 100644
--- a/generator/generator.cpp
+++ b/generator/generator.cpp
@@ -73,7 +73,7 @@ bool Generator::setup(const ApiExtractor& extractor, const QMap< QString, QStrin
     TypeEntryHash allEntries = TypeDatabase::instance()->allEntries();
     TypeEntry* entryFound = 0;
     for (TypeEntryHash::const_iterator it = allEntries.cbegin(), end = allEntries.cend(); it != end; ++it) {
-        foreach (TypeEntry *entry, it.value()) {
+        for (TypeEntry *entry : it.value()) {
             if (entry->type() == TypeEntry::TypeSystemType && entry->generateCode()) {
                 entryFound = entry;
                 break;
@@ -120,7 +120,8 @@ void Generator::addInstantiatedContainersAndSmartPointers(const AbstractMetaType
 {
     if (!type)
         return;
-    foreach (const AbstractMetaType* t, type->instantiations())
+    const AbstractMetaTypeList &instantiations = type->instantiations();
+    for (const AbstractMetaType* t : instantiations)
         addInstantiatedContainersAndSmartPointers(t, context);
     if (!type->typeEntry()->isContainer() && !type->typeEntry()->isSmartPointer())
         return;
@@ -156,7 +157,8 @@ void Generator::addInstantiatedContainersAndSmartPointers(const AbstractMetaType
 void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMetaFunction *func)
 {
     addInstantiatedContainersAndSmartPointers(func->type(), func->signature());
-    foreach (const AbstractMetaArgument* arg, func->arguments())
+    const AbstractMetaArgumentList &arguments = func->arguments();
+    for (const AbstractMetaArgument *arg : arguments)
         addInstantiatedContainersAndSmartPointers(arg->type(), func->signature());
 }
 
@@ -164,19 +166,24 @@ void Generator::collectInstantiatedContainersAndSmartPointers(const AbstractMeta
 {
     if (!metaClass->typeEntry()->generateCode())
         return;
-    foreach (const AbstractMetaFunction* func, metaClass->functions())
+    const AbstractMetaFunctionList &funcs = metaClass->functions();
+    for (const AbstractMetaFunction *func : funcs)
         collectInstantiatedContainersAndSmartPointers(func);
-    foreach (const AbstractMetaField* field, metaClass->fields())
+    const AbstractMetaFieldList &fields = metaClass->fields();
+    for (const AbstractMetaField *field : fields)
         addInstantiatedContainersAndSmartPointers(field->type(), field->name());
-    foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
+    const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
+    for (AbstractMetaClass *innerClass : innerClasses)
         collectInstantiatedContainersAndSmartPointers(innerClass);
 }
 
 void Generator::collectInstantiatedContainersAndSmartPointers()
 {
-    foreach (const AbstractMetaFunction* func, globalFunctions())
+    const AbstractMetaFunctionList &funcs = globalFunctions();
+    for (const AbstractMetaFunction *func : funcs)
         collectInstantiatedContainersAndSmartPointers(func);
-    foreach (const AbstractMetaClass* metaClass, classes())
+    const AbstractMetaClassList &classList = classes();
+    for (const AbstractMetaClass *metaClass : classList)
         collectInstantiatedContainersAndSmartPointers(metaClass);
 }
 
@@ -351,13 +358,14 @@ QString Generator::getFileNameBaseForSmartPointer(const AbstractMetaType *smartP
 
 bool Generator::generate()
 {
-    foreach (AbstractMetaClass *cls, m_d->apiextractor->classes()) {
+    const AbstractMetaClassList &classList = m_d->apiextractor->classes();
+    for (AbstractMetaClass *cls : classList) {
         GeneratorContext context(cls);
         if (!generateFileForContext(context))
             return false;
     }
 
-    foreach (const AbstractMetaType *type, instantiatedSmartPointers()) {
+    for (const AbstractMetaType *type : qAsConst(m_d->instantiatedSmartPointers)) {
         AbstractMetaClass *smartPointerClass =
                 AbstractMetaClass::findClass(m_d->apiextractor->smartPointers(), type->name());
         GeneratorContext context(smartPointerClass, type, true);
@@ -394,7 +402,8 @@ void Generator::replaceTemplateVariables(QString &code, const AbstractMetaFuncti
     if (cpp_class)
         code.replace(QLatin1String("%TYPE"), cpp_class->name());
 
-    foreach (AbstractMetaArgument *arg, func->arguments())
+    const AbstractMetaArgumentList &argument = func->arguments();
+    for (AbstractMetaArgument *arg : argument)
         code.replace(QLatin1Char('%') + QString::number(arg->argumentIndex() + 1), arg->name());
 
     //template values
@@ -419,10 +428,10 @@ void Generator::replaceTemplateVariables(QString &code, const AbstractMetaFuncti
 QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
 {
     // detect number of spaces before the first character
-    QStringList lst(code.split(QLatin1Char('\n')));
+    const QStringList lst(code.split(QLatin1Char('\n')));
     QRegExp nonSpaceRegex(QLatin1String("[^\\s]"));
     int spacesToRemove = 0;
-    foreach(QString line, lst) {
+    for (const QString &line : lst) {
         if (!line.trimmed().isEmpty()) {
             spacesToRemove = line.indexOf(nonSpaceRegex);
             if (spacesToRemove == -1)
@@ -433,7 +442,7 @@ QTextStream& formatCode(QTextStream &s, const QString& code, Indentor &indentor)
 
     static QRegExp emptyLine(QLatin1String("\\s*[\\r]?[\\n]?\\s*"));
 
-    foreach(QString line, lst) {
+    for (QString line : lst) {
         if (!line.isEmpty() && !emptyLine.exactMatch(line)) {
             while (line.end()->isSpace())
                 line.chop(1);
@@ -639,9 +648,9 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
     if (cType->hasDefaultConstructor())
         return cType->defaultConstructor();
 
-    AbstractMetaFunctionList constructors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
+    const AbstractMetaFunctionList &constructors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
     int maxArgs = 0;
-    foreach (const AbstractMetaFunction* ctor, constructors) {
+    for (const AbstractMetaFunction *ctor : constructors) {
         if (ctor->isUserAdded() || ctor->isPrivate() || ctor->functionType() != AbstractMetaFunction::ConstructorFunction)
             continue;
 
@@ -656,7 +665,8 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
 
     QString qualifiedCppName = metaClass->typeEntry()->qualifiedCppName();
     QStringList templateTypes;
-    foreach (TypeEntry* templateType, metaClass->templateArguments())
+    const QList<TypeEntry *> &templateArguments = metaClass->templateArguments();
+    for (TypeEntry *templateType : templateArguments)
         templateTypes << templateType->qualifiedCppName();
 
     // Empty constructor.
@@ -668,16 +678,16 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
     // Constructors with C++ primitive types, enums or pointers only.
     // Start with the ones with fewer arguments.
     for (int i = 1; i <= maxArgs; ++i) {
-        foreach (const AbstractMetaFunction* ctor, constructors) {
+        for (const AbstractMetaFunction *ctor : constructors) {
             if (ctor->isUserAdded() || ctor->isPrivate() || ctor->functionType() != AbstractMetaFunction::ConstructorFunction)
                 continue;
 
-            AbstractMetaArgumentList arguments = ctor->arguments();
+            const AbstractMetaArgumentList &arguments = ctor->arguments();
             if (arguments.size() != i)
                 continue;
 
             QStringList args;
-            foreach (const AbstractMetaArgument* arg, arguments) {
+            for (const AbstractMetaArgument *arg : arguments) {
                 const TypeEntry* type = arg->type()->typeEntry();
                 if (type == metaClass->typeEntry()) {
                     args.clear();
@@ -715,9 +725,10 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
     // Constructors with C++ primitive types, enums, pointers, value types,
     // and user defined primitive types.
     // Builds the minimal constructor recursively.
-    foreach (const AbstractMetaFunction* ctor, candidates) {
+    for (const AbstractMetaFunction *ctor : qAsConst(candidates)) {
         QStringList args;
-        foreach (const AbstractMetaArgument* arg, ctor->arguments()) {
+        const AbstractMetaArgumentList &arguments = ctor->arguments();
+        for (const AbstractMetaArgument *arg : arguments) {
             if (arg->type()->typeEntry() == metaClass->typeEntry()) {
                 args.clear();
                 break;
diff --git a/generator/main.cpp b/generator/main.cpp
index 874540e..f0e334d 100644
--- a/generator/main.cpp
+++ b/generator/main.cpp
@@ -206,7 +206,7 @@ static QMap<QString, QString> getInitializedArguments()
     arguments.removeFirst();
 
     QString projectFileName;
-    foreach (const QString& arg, arguments) {
+    for (const QString &arg : qAsConst(arguments)) {
         if (arg.startsWith(QLatin1String("--project-file"))) {
             int split = arg.indexOf(QLatin1Char('='));
             if (split > 0)
@@ -246,7 +246,7 @@ static QMap<QString, QString> getCommandLineArgs()
     arguments.removeFirst();
 
     int argNum = 0;
-    foreach (const QString &carg, arguments) {
+    for (const QString &carg : qAsConst(arguments)) {
         const QString &arg = carg.trimmed();
         if (arg.startsWith(QLatin1String("--"))) {
             int split = arg.indexOf(QLatin1Char('='));
@@ -318,7 +318,7 @@ void printUsage()
     printOptions(s, generalOptions);
 
     const Generators generators = shibokenGenerators() + docGenerators();
-    foreach (const GeneratorPtr &generator, generators) {
+    for (const GeneratorPtr &generator : generators) {
         QMap<QString, QString> options = generator->options();
         if (!options.isEmpty()) {
             s << endl << generator->name() << " options:\n";
@@ -437,8 +437,8 @@ int main(int argc, char *argv[])
         extractor.setSuppressWarnings(false);
 
     if (argsHandler.argExists(QLatin1String("api-version"))) {
-        QStringList versions = argsHandler.removeArg(QLatin1String("api-version")).split(QLatin1Char('|'));
-        foreach (const QString &fullVersion, versions) {
+        const QStringList &versions = argsHandler.removeArg(QLatin1String("api-version")).split(QLatin1Char('|'));
+        for (const QString &fullVersion : versions) {
             QStringList parts = fullVersion.split(QLatin1Char(','));
             QString package;
             QString version;
@@ -478,7 +478,7 @@ int main(int argc, char *argv[])
         for ( ; it != projectFileArgs.constEnd(); ++it)
             argsHandler.removeArg(it.key());
     }
-    foreach (const GeneratorPtr &generator, generators) {
+    for (const GeneratorPtr &generator : qAsConst(generators)) {
         QMap<QString, QString> options = generator->options();
         if (!options.isEmpty()) {
             QMap<QString, QString>::const_iterator it = options.constBegin();
@@ -505,7 +505,7 @@ int main(int argc, char *argv[])
 
     qCDebug(lcShiboken) << extractor;
 
-    foreach (const GeneratorPtr &g, generators) {
+    for (const GeneratorPtr &g : qAsConst(generators)) {
         g->setOutputDirectory(outputDirectory);
         g->setLicenseComment(licenseComment);
          if (g->setup(extractor, args)) {
diff --git a/generator/qtdoc/qtdocgenerator.cpp b/generator/qtdoc/qtdocgenerator.cpp
index a7a1769..02fd403 100644
--- a/generator/qtdoc/qtdocgenerator.cpp
+++ b/generator/qtdoc/qtdocgenerator.cpp
@@ -55,7 +55,8 @@ static bool shouldSkip(const AbstractMetaFunction* func)
     // Search a const clone
     if (!skipable && !func->isConstant()) {
         const AbstractMetaArgumentList funcArgs = func->arguments();
-        foreach (AbstractMetaFunction* f, func->ownerClass()->functions()) {
+        const AbstractMetaFunctionList &ownerFunctions = func->ownerClass()->functions();
+        for (AbstractMetaFunction *f : ownerFunctions) {
             if (f != func
                 && f->isConstant()
                 && f->name() == func->name()
@@ -202,7 +203,8 @@ QString QtXmlToSphinx::expandFunction(const QString& function)
     QStringList functionSpec = function.split(QLatin1Char('.'));
     QString className = functionSpec.first();
     const AbstractMetaClass* metaClass = 0;
-    foreach (const AbstractMetaClass* cls, m_generator->classes()) {
+    const AbstractMetaClassList &classes = m_generator->classes();
+    for (const AbstractMetaClass *cls : classes) {
         if (cls->name() == className) {
             metaClass = cls;
             break;
@@ -224,7 +226,8 @@ QString QtXmlToSphinx::resolveContextForMethod(const QString& methodName)
     QString currentClass = m_context.split(QLatin1Char('.')).last();
 
     const AbstractMetaClass* metaClass = 0;
-    foreach (const AbstractMetaClass* cls, m_generator->classes()) {
+    const AbstractMetaClassList &classes = m_generator->classes();
+    for (const AbstractMetaClass *cls : classes) {
         if (cls->name() == currentClass) {
             metaClass = cls;
             break;
@@ -233,13 +236,14 @@ QString QtXmlToSphinx::resolveContextForMethod(const QString& methodName)
 
     if (metaClass) {
         QList<const AbstractMetaFunction*> funcList;
-        foreach (const AbstractMetaFunction* func, metaClass->queryFunctionsByName(methodName)) {
+        const AbstractMetaFunctionList &methods = metaClass->queryFunctionsByName(methodName);
+        for (const AbstractMetaFunction *func : methods) {
             if (methodName == func->name())
                 funcList.append(func);
         }
 
         const AbstractMetaClass* implementingClass = 0;
-        foreach (const AbstractMetaFunction* func, funcList) {
+        for (const AbstractMetaFunction *func : qAsConst(funcList)) {
             implementingClass = func->implementingClass();
             if (implementingClass->name() == currentClass)
                 break;
@@ -300,7 +304,7 @@ QString QtXmlToSphinx::readFromLocations(const QStringList& locations, const QSt
 {
     QString result;
     bool ok;
-    foreach (QString location, locations) {
+    for (QString location : locations) {
         location.append(QLatin1Char('/'));
         location.append(path);
         result = readFromLocation(location, identifier, &ok);
@@ -466,7 +470,8 @@ void QtXmlToSphinx::handleSnippetTag(QXmlStreamReader& reader)
         if (code.isEmpty()) {
             m_output << INDENT << "<Code snippet \"" << location << ':' << identifier << "\" not found>" << endl;
         } else {
-            foreach (const QString &line, code.split(QLatin1Char('\n'))) {
+            const QStringList lines = code.split(QLatin1Char('\n'));
+            for (const QString &line : lines) {
                 if (!QString(line).trimmed().isEmpty())
                     m_output << INDENT << line;
 
@@ -577,7 +582,7 @@ void QtXmlToSphinx::handleListTag(QXmlStreamReader& reader)
         if (!m_currentTable.isEmpty()) {
             if (listType == QLatin1String("bullet")) {
                 m_output << endl;
-                foreach (TableCell cell, m_currentTable.first()) {
+                for (const TableCell &cell : m_currentTable.constFirst()) {
                     QStringList itemLines = cell.data.split(QLatin1Char('\n'));
                     m_output << INDENT << "* " << itemLines.first() << endl;
                     for (int i = 1, max = itemLines.count(); i < max; ++i)
@@ -714,8 +719,8 @@ void QtXmlToSphinx::handleRawTag(QXmlStreamReader& reader)
         QString format = reader.attributes().value(QLatin1String("format")).toString();
         m_output << INDENT << ".. raw:: " << format.toLower() << endl << endl;
     } else if (token == QXmlStreamReader::Characters) {
-        QStringList lst(reader.text().toString().split(QLatin1Char('\n')));
-        foreach(QString row, lst)
+        const QStringList lst(reader.text().toString().split(QLatin1Char('\n')));
+        for (const QString &row : lst)
             m_output << INDENT << INDENT << row << endl;
     } else if (token == QXmlStreamReader::EndElement) {
         m_output << endl << endl;
@@ -730,8 +735,8 @@ void QtXmlToSphinx::handleCodeTag(QXmlStreamReader& reader)
         m_output << INDENT << "::" << endl << endl;
         INDENT.indent++;
     } else if (token == QXmlStreamReader::Characters) {
-        QStringList lst(reader.text().toString().split(QLatin1Char('\n')));
-        foreach(QString row, lst)
+        const QStringList lst(reader.text().toString().split(QLatin1Char('\n')));
+        for (const QString row : lst)
             m_output << INDENT << INDENT << row << endl;
     } else if (token == QXmlStreamReader::EndElement) {
         m_output << endl << endl;
@@ -802,7 +807,8 @@ void QtXmlToSphinx::handleQuoteFileTag(QXmlStreamReader& reader)
         if (code.isEmpty()) {
             m_output << INDENT << "<Code snippet \"" << location << "\" not found>" << endl;
         } else {
-            foreach (QString line, code.split(QLatin1Char('\n'))) {
+            const QStringList lines = code.split(QLatin1Char('\n'));
+            for (const QString &line : lines) {
                 if (!QString(line).trimmed().isEmpty())
                     m_output << INDENT << line;
 
@@ -882,8 +888,8 @@ QTextStream& operator<<(QTextStream& s, const QtXmlToSphinx::Table &table)
     for (int i = 0, maxI = table.count(); i < maxI; ++i) {
         const QtXmlToSphinx::TableRow& row = table[i];
         for (int j = 0, maxJ = std::min(row.count(), colWidths.size()); j < maxJ; ++j) {
-            QStringList rowLines = row[j].data.split(QLatin1Char('\n')); // cache this would be a good idea
-            foreach (QString str, rowLines)
+            const QStringList rowLines = row[j].data.split(QLatin1Char('\n')); // cache this would be a good idea
+            for (const QString &str : rowLines)
                 colWidths[j] = std::max(colWidths[j], str.count());
             rowHeights[i] = std::max(rowHeights[i], row[j].data.count(QLatin1Char('\n')) + 1);
         }
@@ -1018,16 +1024,16 @@ void QtDocGenerator::writeFormatedText(QTextStream& s, const Documentation& doc,
         QtXmlToSphinx x(this, doc.value(), metaClassName);
         s << x;
     } else {
-        QStringList lines = doc.value().split(QLatin1Char('\n'));
+        const QStringList lines = doc.value().split(QLatin1Char('\n'));
         QRegExp regex(QLatin1String("\\S")); // non-space character
         int typesystemIndentation = std::numeric_limits<int>().max();
         // check how many spaces must be removed from the begining of each line
-        foreach (QString line, lines) {
+        for (const QString &line : lines) {
             int idx = line.indexOf(regex);
             if (idx >= 0)
                 typesystemIndentation = qMin(typesystemIndentation, idx);
         }
-        foreach (QString line, lines)
+        for (QString line : lines)
             s << INDENT << line.remove(0, typesystemIndentation) << endl;
     }
 
@@ -1037,7 +1043,7 @@ void QtDocGenerator::writeFormatedText(QTextStream& s, const Documentation& doc,
 static void writeInheritedByList(QTextStream& s, const AbstractMetaClass* metaClass, const AbstractMetaClassList& allClasses)
 {
     AbstractMetaClassList res;
-    foreach (AbstractMetaClass* c, allClasses) {
+    for (AbstractMetaClass *c : allClasses) {
         if (c != metaClass && c->inheritsFrom(metaClass))
             res << c;
     }
@@ -1047,7 +1053,7 @@ static void writeInheritedByList(QTextStream& s, const AbstractMetaClass* metaCl
 
     s << "**Inherited by:** ";
     QStringList classes;
-    foreach (AbstractMetaClass* c, res)
+    for (AbstractMetaClass *c : qAsConst(res))
         classes << QLatin1String(":ref:`") + getClassTargetFullName(c, false) + QLatin1Char('`');
     s << classes.join(QLatin1String(", ")) << endl << endl;
 }
@@ -1098,7 +1104,7 @@ void QtDocGenerator::generateClass(QTextStream &s, GeneratorContext &classContex
         writeFields(s, metaClass);
 
 
-    foreach (AbstractMetaFunction* func, functionList) {
+    for (AbstractMetaFunction *func : qAsConst(functionList)) {
         if (shouldSkip(func))
             continue;
 
@@ -1121,7 +1127,8 @@ void QtDocGenerator::writeFunctionList(QTextStream& s, const AbstractMetaClass*
     QStringList slotList;
     QStringList staticFunctionList;
 
-    foreach (AbstractMetaFunction* func, cppClass->functions()) {
+    const AbstractMetaFunctionList &classFunctions = cppClass->functions();
+    for (AbstractMetaFunction *func : classFunctions) {
         if (shouldSkip(func))
             continue;
 
@@ -1180,7 +1187,7 @@ void QtDocGenerator::writeFunctionBlock(QTextStream& s, const QString& title, QS
 
         s << ".. container:: function_list" << endl << endl;
         Indentation indentation(INDENT);
-        foreach (QString func, functions)
+        for (const QString &func : qAsConst(functions))
             s << '*' << INDENT << func << endl;
 
         s << endl << endl;
@@ -1191,7 +1198,8 @@ void QtDocGenerator::writeEnums(QTextStream& s, const AbstractMetaClass* cppClas
 {
     static const QString section_title = QLatin1String(".. attribute:: ");
 
-    foreach (AbstractMetaEnum* en, cppClass->enums()) {
+    const AbstractMetaEnumList &enums = cppClass->enums();
+    for (AbstractMetaEnum *en : enums) {
         s << section_title << getClassTargetFullName(cppClass) << '.' << en->name() << endl << endl;
         writeFormatedText(s, en->documentation(), cppClass);
 
@@ -1205,7 +1213,8 @@ void QtDocGenerator::writeFields(QTextStream& s, const AbstractMetaClass* cppCla
 {
     static const QString section_title = QLatin1String(".. attribute:: ");
 
-    foreach (AbstractMetaField* field, cppClass->fields()) {
+    const AbstractMetaFieldList &fields = cppClass->fields();
+    for (AbstractMetaField *field : fields) {
         s << section_title << getClassTargetFullName(cppClass) << "." << field->name() << endl << endl;
         //TODO: request for member ‘documentation’ is ambiguous
         writeFormatedText(s, field->AbstractMetaAttributes::documentation(), cppClass);
@@ -1217,12 +1226,12 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
     static const QString sectionTitle = QLatin1String(".. class:: ");
     static const QString sectionTitleSpace = QString(sectionTitle.size(), QLatin1Char(' '));
 
-    AbstractMetaFunctionList lst = cppClass->queryFunctions(AbstractMetaClass::Constructors | AbstractMetaClass::Visible);
+    const AbstractMetaFunctionList lst = cppClass->queryFunctions(AbstractMetaClass::Constructors | AbstractMetaClass::Visible);
 
     bool first = true;
     QHash<QString, AbstractMetaArgument*> arg_map;
 
-    foreach(AbstractMetaFunction* func, lst) {
+    for (AbstractMetaFunction *func : lst) {
         if (func->isModifiedRemoved())
             continue;
 
@@ -1233,8 +1242,8 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
             s << sectionTitleSpace;
         }
         writeFunction(s, false, cppClass, func);
-        foreach(AbstractMetaArgument* arg, func->arguments())
-        {
+        const AbstractMetaArgumentList &arguments = func->arguments();
+        for (AbstractMetaArgument *arg : arguments) {
             if (!arg_map.contains(arg->name())) {
                 arg_map.insert(arg->name(), arg);
             }
@@ -1243,16 +1252,15 @@ void QtDocGenerator::writeConstructors(QTextStream& s, const AbstractMetaClass*
 
     s << endl;
 
-    foreach (AbstractMetaArgument* arg, arg_map.values()) {
+    for (QHash<QString, AbstractMetaArgument*>::const_iterator it = arg_map.cbegin(), end = arg_map.cend(); it != end; ++it) {
         Indentation indentation(INDENT);
-        writeParamerteType(s, cppClass, arg);
+        writeParamerteType(s, cppClass, it.value());
     }
 
     s << endl;
 
-    foreach (AbstractMetaFunction* func, lst) {
+    for (AbstractMetaFunction *func : lst)
         writeFormatedText(s, func->documentation(), cppClass);
-    }
 }
 
 QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* cppClass, const AbstractMetaFunction* func)
@@ -1260,7 +1268,8 @@ QString QtDocGenerator::parseArgDocStyle(const AbstractMetaClass* cppClass, cons
     QString ret;
     int optArgs = 0;
 
-    foreach (AbstractMetaArgument* arg, func->arguments()) {
+    const AbstractMetaArgumentList &arguments = func->arguments();
+    for (AbstractMetaArgument *arg : arguments) {
 
         if (func->argumentRemoved(arg->argumentIndex() + 1))
             continue;
@@ -1311,7 +1320,7 @@ void QtDocGenerator::writeDocSnips(QTextStream &s,
 
     invalidStrings << QLatin1String("*") << QLatin1String("//") << QLatin1String("/*") << QLatin1String("*/");
 
-    foreach (CodeSnip snip, codeSnips) {
+    for (const CodeSnip &snip : codeSnips) {
         if ((snip.position != position) ||
             !(snip.language & language))
             continue;
@@ -1325,14 +1334,13 @@ void QtDocGenerator::writeDocSnips(QTextStream &s,
                 break;
 
             QString codeBlock = code.mid(startBlock, endBlock - startBlock);
-            QStringList rows = codeBlock.split(QLatin1Char('\n'));
+            const QStringList rows = codeBlock.split(QLatin1Char('\n'));
             int currenRow = 0;
             int offset = 0;
 
-            foreach(QString row, rows) {
-                foreach(QString invalidString, invalidStrings) {
-                    row = row.remove(invalidString);
-                }
+            for (QString row : rows) {
+                for (const QString &invalidString : qAsConst(invalidStrings))
+                    row.remove(invalidString);
 
                 if (row.trimmed().size() == 0) {
                     if (currenRow == 0)
@@ -1370,7 +1378,8 @@ bool QtDocGenerator::writeInjectDocumentation(QTextStream& s,
     Indentation indentation(INDENT);
     bool didSomething = false;
 
-    foreach (DocModification mod, cppClass->typeEntry()->docModifications()) {
+    const DocModificationList &mods = cppClass->typeEntry()->docModifications();
+    for (const DocModification &mod : mods) {
         if (mod.mode() == mode) {
             bool modOk = func ? mod.signature() == func->minimalSignature() : mod.signature().isEmpty();
 
@@ -1473,7 +1482,8 @@ void QtDocGenerator::writeFunctionParametersType(QTextStream& s, const AbstractM
     Indentation indentation(INDENT);
 
     s << endl;
-    foreach (AbstractMetaArgument* arg, func->arguments()) {
+    const AbstractMetaArgumentList &funcArgs = func->arguments();
+    for (AbstractMetaArgument *arg : funcArgs) {
 
         if (func->argumentRemoved(arg->argumentIndex() + 1))
             continue;
@@ -1485,8 +1495,9 @@ void QtDocGenerator::writeFunctionParametersType(QTextStream& s, const AbstractM
 
         QString retType;
         // check if the return type was modified
-        foreach (FunctionModification mod, func->modifications()) {
-            foreach (ArgumentModification argMod, mod.argument_mods) {
+        const FunctionModificationList &mods = func->modifications();
+        for (const FunctionModification &mod : mods) {
+            for (const ArgumentModification &argMod : mod.argument_mods) {
                 if (argMod.index == 0) {
                     retType = argMod.modified_type;
                     break;
@@ -1526,7 +1537,7 @@ static void writeFancyToc(QTextStream& s, const QStringList& items, int cols = 4
     TocMap tocMap;
     QChar Q = QLatin1Char('Q');
     QChar idx;
-    foreach (QString item, items) {
+    for (QString item : items) {
         if (item.isEmpty())
             continue;
         if (item.startsWith(Q) && item.length() > 1)
@@ -1551,7 +1562,7 @@ static void writeFancyToc(QTextStream& s, const QStringList& items, int cols = 4
 
         ss << "**" << it.key() << "**" << endl << endl;
         i += 2; // a letter title is equivalent to two entries in space
-        foreach (QString item, it.value()) {
+        for (const QString &item : qAsConst(it.value())) {
             ss << "* :doc:`" << item << "`" << endl;
             ++i;
 
@@ -1628,7 +1639,7 @@ bool QtDocGenerator::finishGeneration()
             s << INDENT << ".. toctree::" << endl;
             Indentation deeperIndentation(INDENT);
             s << INDENT << ":maxdepth: 1" << endl << endl;
-            foreach (QString className, it.value())
+            for (const QString &className : qAsConst(it.value()))
                 s << INDENT << className << endl;
             s << endl << endl;
         }
diff --git a/generator/shiboken2/cppgenerator.cpp b/generator/shiboken2/cppgenerator.cpp
index f5bcdce..0d13cad 100644
--- a/generator/shiboken2/cppgenerator.cpp
+++ b/generator/shiboken2/cppgenerator.cpp
@@ -159,7 +159,8 @@ QList<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(con
     // ( func_name, num_args ) => func_list
     QMap<QPair<QString, int >, AbstractMetaFunctionList> results;
     const AbstractMetaClass::OperatorQueryOptions query(queryIn);
-    foreach (AbstractMetaFunction* func, metaClass->operatorOverloads(query)) {
+    const AbstractMetaFunctionList &funcs = metaClass->operatorOverloads(query);
+    for (AbstractMetaFunction *func : funcs) {
         if (func->isModifiedRemoved()
             || func->usesRValueReferences()
             || func->name() == QLatin1String("operator[]")
@@ -250,7 +251,8 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
     QString headerfile = fileNameForContext(classContext);
     headerfile.replace(QLatin1String(".cpp"), QLatin1String(".h"));
     s << "#include \"" << headerfile << '"' << endl;
-    foreach (AbstractMetaClass* innerClass, metaClass->innerClasses()) {
+    const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
+    for (AbstractMetaClass *innerClass : innerClasses) {
         GeneratorContext innerClassContext(innerClass);
         if (shouldGenerate(innerClass)) {
             QString headerfile = fileNameForContext(innerClassContext);
@@ -260,16 +262,16 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
     }
 
     AbstractMetaEnumList classEnums = metaClass->enums();
-    foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
+    for (AbstractMetaClass *innerClass : innerClasses)
         lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
 
     //Extra includes
     s << endl << "// Extra includes" << endl;
     QList<Include> includes = metaClass->typeEntry()->extraIncludes();
-    foreach (AbstractMetaEnum* cppEnum, classEnums)
+    for (AbstractMetaEnum *cppEnum : qAsConst(classEnums))
         includes.append(cppEnum->typeEntry()->extraIncludes());
     qSort(includes.begin(), includes.end());
-    foreach (const Include &inc, includes)
+    for (const Include &inc : qAsConst(includes))
         s << inc.toString() << endl;
     s << endl;
 
@@ -322,7 +324,8 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
             s << "}\n\n";
         }
 
-        foreach (const AbstractMetaFunction* func, filterFunctions(metaClass)) {
+        const AbstractMetaFunctionList &funcs = filterFunctions(metaClass);
+        for (const AbstractMetaFunction *func : funcs) {
             if ((func->isPrivate() && !visibilityModifiedToPrivate(func))
                 || (func->isModifiedRemoved() && !func->isAbstract()))
                 continue;
@@ -352,7 +355,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
     const FunctionGroupMap &functionGroups = getFunctionGroups(metaClass);
     for (FunctionGroupMapIt it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
         AbstractMetaFunctionList overloads;
-        foreach (AbstractMetaFunction* func, it.value()) {
+        for (AbstractMetaFunction *func : it.value()) {
             if (!func->isAssignmentOperator()
                 && !func->usesRValueReferences()
                 && !func->isCastOperator()
@@ -469,15 +472,15 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
     }
 
     if (supportsNumberProtocol(metaClass) && !metaClass->typeEntry()->isSmartPointer()) {
-        QList<AbstractMetaFunctionList> opOverloads = filterGroupedOperatorFunctions(
+        const QList<AbstractMetaFunctionList> opOverloads = filterGroupedOperatorFunctions(
                 metaClass,
                 AbstractMetaClass::ArithmeticOp
                 | AbstractMetaClass::LogicalOp
                 | AbstractMetaClass::BitwiseOp);
 
-        foreach (const AbstractMetaFunctionList &allOverloads, opOverloads) {
+        for (const AbstractMetaFunctionList &allOverloads : opOverloads) {
             AbstractMetaFunctionList overloads;
-            foreach (AbstractMetaFunction* func, allOverloads) {
+            for (AbstractMetaFunction *func : allOverloads) {
                 if (!func->isModifiedRemoved()
                     && !func->isPrivate()
                     && (func->ownerClass() == func->implementingClass() || func->isAbstract()))
@@ -505,7 +508,8 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
     }
 
     if (shouldGenerateGetSetList(metaClass) && !classContext.forSmartPointer()) {
-        foreach (const AbstractMetaField* metaField, metaClass->fields()) {
+        const AbstractMetaFieldList &fields = metaClass->fields();
+        for (const AbstractMetaField *metaField : fields) {
             if (metaField->isStatic())
                 continue;
             writeGetterFunction(s, metaField, classContext);
@@ -516,7 +520,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
 
         s << "// Getters and Setters for " << metaClass->name() << endl;
         s << "static PyGetSetDef " << cpythonGettersSettersDefinitionName(metaClass) << "[] = {" << endl;
-        foreach (const AbstractMetaField* metaField, metaClass->fields()) {
+        for (const AbstractMetaField *metaField : fields) {
             if (metaField->isStatic())
                 continue;
 
@@ -546,7 +550,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
         writeTypeDiscoveryFunction(s, metaClass);
 
 
-    foreach (AbstractMetaEnum* cppEnum, classEnums) {
+    for (AbstractMetaEnum *cppEnum : qAsConst(classEnums)) {
         if (cppEnum->isAnonymous() || cppEnum->isPrivate())
             continue;
 
@@ -598,7 +602,8 @@ static bool allArgumentsRemoved(const AbstractMetaFunction* func)
 {
     if (func->arguments().isEmpty())
         return false;
-    foreach (const AbstractMetaArgument* arg, func->arguments()) {
+    const AbstractMetaArgumentList &arguments = func->arguments();
+    for (const AbstractMetaArgument *arg : arguments) {
         if (!func->argumentRemoved(arg->argumentIndex() + 1))
             return false;
     }
@@ -650,8 +655,9 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
 
     QString defaultReturnExpr;
     if (retType) {
-        foreach (const FunctionModification &mod, func->modifications()) {
-            foreach (const ArgumentModification &argMod, mod.argument_mods) {
+        const FunctionModificationList &mods = func->modifications();
+        for (const FunctionModification &mod : mods) {
+            for (const ArgumentModification &argMod : mod.argument_mods) {
                 if (argMod.index == 0 && !argMod.replacedDefaultExpression.isEmpty()) {
                     QRegExp regex(QLatin1String("%(\\d+)"));
                     defaultReturnExpr = argMod.replacedDefaultExpression;
@@ -744,7 +750,8 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
         s << "PyTuple_New(0));" << endl;
     } else {
         QStringList argConversions;
-        foreach (const AbstractMetaArgument* arg, func->arguments()) {
+        const AbstractMetaArgumentList &arguments = func->arguments();
+        for (const AbstractMetaArgument *arg : arguments) {
             if (func->argumentRemoved(arg->argumentIndex() + 1))
                 continue;
 
@@ -790,8 +797,9 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
 
     bool invalidateReturn = false;
     QSet<int> invalidateArgs;
-    foreach (const FunctionModification &funcMod, func->modifications()) {
-        foreach (const ArgumentModification &argMod, funcMod.argument_mods) {
+    const FunctionModificationList &mods = func->modifications();
+    for (const FunctionModification &funcMod : mods) {
+        for (const ArgumentModification &argMod : funcMod.argument_mods) {
             if (argMod.resetAfterUse && !invalidateArgs.contains(argMod.index)) {
                 invalidateArgs.insert(argMod.index);
                 s << INDENT << "bool invalidateArg" << argMod.index;
@@ -888,7 +896,7 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
         Indentation indentation(INDENT);
         s << INDENT << "Shiboken::Object::releaseOwnership(" << PYTHON_RETURN_VAR  ".object());" << endl;
     }
-    foreach (int argIndex, invalidateArgs) {
+    for (int argIndex : qAsConst(invalidateArgs)) {
         s << INDENT << "if (invalidateArg" << argIndex << ')' << endl;
         Indentation indentation(INDENT);
         s << INDENT << "Shiboken::Object::invalidate(PyTuple_GET_ITEM(" PYTHON_ARGS ", ";
@@ -896,8 +904,9 @@ void CppGenerator::writeVirtualMethodNative(QTextStream&s, const AbstractMetaFun
     }
 
 
-    foreach (const FunctionModification &funcMod, func->modifications()) {
-        foreach (const ArgumentModification &argMod, funcMod.argument_mods) {
+    const FunctionModificationList &funcMods = func->modifications();
+    for (const FunctionModification &funcMod : funcMods) {
+        for (const ArgumentModification &argMod : funcMod.argument_mods) {
             if (argMod.ownerships.contains(TypeSystem::NativeCode)
                 && argMod.index == 0 && argMod.ownerships[TypeSystem::NativeCode] == TypeSystem::CppOwnership) {
                 s << INDENT << "if (Shiboken::Object::checkType(" PYTHON_RETURN_VAR "))" << endl;
@@ -1070,11 +1079,12 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     s << "// Type conversion functions." << endl << endl;
 
     AbstractMetaEnumList classEnums = metaClass->enums();
-    foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
+    const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
+    for (AbstractMetaClass *innerClass : innerClasses)
         lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
     if (!classEnums.isEmpty())
         s << "// Python to C++ enum conversion." << endl;
-    foreach (const AbstractMetaEnum* metaEnum, classEnums)
+    for (const AbstractMetaEnum *metaEnum : qAsConst(classEnums))
         writeEnumConverterFunctions(s, metaEnum);
 
     if (metaClass->isNamespace())
@@ -1184,7 +1194,8 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     // Implicit conversions.
     AbstractMetaFunctionList implicitConvs;
     if (!customConversion || !customConversion->replaceOriginalTargetToNativeConversions()) {
-        foreach (AbstractMetaFunction* func, implicitConversions(metaClass->typeEntry())) {
+        const AbstractMetaFunctionList &allImplicitConvs = implicitConversions(metaClass->typeEntry());
+        for (AbstractMetaFunction *func : allImplicitConvs) {
             if (!func->isUserAdded())
                 implicitConvs << func;
         }
@@ -1194,7 +1205,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
         s << "// Implicit conversions." << endl;
 
     AbstractMetaType* targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
-    foreach (const AbstractMetaFunction* conv, implicitConvs) {
+    for (const AbstractMetaFunction* conv : qAsConst(implicitConvs)) {
         if (conv->isModifiedRemoved())
             continue;
 
@@ -1268,7 +1279,7 @@ void CppGenerator::writeCustomConverterFunctions(QTextStream& s, const CustomCon
     if (toCppConversions.isEmpty())
         return;
     s << "// Python to C++ conversions for type '" << customConversion->ownerType()->qualifiedCppName() << "'." << endl;
-    foreach (CustomConversion::TargetToNativeConversion* toNative, toCppConversions)
+    for (CustomConversion::TargetToNativeConversion *toNative : toCppConversions)
         writePythonToCppConversionFunctions(s, toNative, customConversion->ownerType());
     s << endl;
 }
@@ -1348,7 +1359,8 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
     // Add implicit conversions.
     AbstractMetaFunctionList implicitConvs;
     if (!customConversion || !customConversion->replaceOriginalTargetToNativeConversions()) {
-        foreach (AbstractMetaFunction* func, implicitConversions(metaClass->typeEntry())) {
+        const AbstractMetaFunctionList &allImplicitConvs = implicitConversions(metaClass->typeEntry());
+        for (AbstractMetaFunction *func : allImplicitConvs) {
             if (!func->isUserAdded())
                 implicitConvs << func;
         }
@@ -1358,7 +1370,7 @@ void CppGenerator::writeConverterRegister(QTextStream &s, const AbstractMetaClas
         s << INDENT << "// Add implicit conversions to type converter." << endl;
 
     AbstractMetaType* targetType = buildAbstractMetaTypeFromAbstractMetaClass(metaClass);
-    foreach (const AbstractMetaFunction* conv, implicitConvs) {
+    for (const AbstractMetaFunction *conv : qAsConst(implicitConvs)) {
         if (conv->isModifiedRemoved())
             continue;
         const AbstractMetaType* sourceType;
@@ -1386,7 +1398,7 @@ void CppGenerator::writeCustomConverterRegister(QTextStream& s, const CustomConv
     if (toCppConversions.isEmpty())
         return;
     s << INDENT << "// Add user defined implicit conversions to type converter." << endl;
-    foreach (CustomConversion::TargetToNativeConversion* toNative, toCppConversions) {
+    for (CustomConversion::TargetToNativeConversion *toNative : toCppConversions) {
         QString toCpp = pythonToCppFunctionName(toNative, customConversion->ownerType());
         QString isConv = convertibleToCppFunctionName(toNative, customConversion->ownerType());
         writeAddPythonToCppConversion(s, converterVar, toCpp, isConv);
@@ -1496,8 +1508,10 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
     QSet<QString> argNamesSet;
     if (usePySideExtensions() && metaClass->isQObject()) {
         // Write argNames variable with all known argument names.
-        foreach (const AbstractMetaFunction* func, overloadData.overloads()) {
-            foreach (const AbstractMetaArgument* arg, func->arguments()) {
+        const QList<const AbstractMetaFunction *> &overloads = overloadData.overloads();
+        for (const AbstractMetaFunction *func : overloads) {
+            const AbstractMetaArgumentList &arguments = func->arguments();
+            for (const AbstractMetaArgument *arg : arguments) {
                 if (arg->defaultValueExpression().isEmpty() || func->argumentRemoved(arg->argumentIndex() + 1))
                     continue;
                 argNamesSet << arg->name();
@@ -1601,8 +1615,9 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
 
     // Constructor code injections, position=end
     bool hasCodeInjectionsAtEnd = false;
-    foreach(AbstractMetaFunction* func, overloads) {
-        foreach (const CodeSnip &cs, func->injectedCodeSnips()) {
+    for (AbstractMetaFunction *func : overloads) {
+        const CodeSnipList &injectedCodeSnips = func->injectedCodeSnips();
+        for (const CodeSnip &cs : injectedCodeSnips) {
             if (cs.position == TypeSystem::CodeSnipPositionEnd) {
                 hasCodeInjectionsAtEnd = true;
                 break;
@@ -1612,9 +1627,10 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
     if (hasCodeInjectionsAtEnd) {
         // FIXME: C++ arguments are not available in code injection on constructor when position = end.
         s << INDENT << "switch(overloadId) {" << endl;
-        foreach(AbstractMetaFunction* func, overloads) {
+        for (AbstractMetaFunction *func : overloads) {
             Indentation indent(INDENT);
-            foreach (const CodeSnip &cs, func->injectedCodeSnips()) {
+            const CodeSnipList &injectedCodeSnips = func->injectedCodeSnips();
+            for (const CodeSnip &cs : injectedCodeSnips) {
                 if (cs.position == TypeSystem::CodeSnipPositionEnd) {
                     s << INDENT << "case " << metaClass->functions().indexOf(func) << ':' << endl;
                     s << INDENT << '{' << endl;
@@ -1795,7 +1811,7 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
     QList<int> invalidArgsLength = overloadData.invalidArgumentLengths();
     if (!invalidArgsLength.isEmpty()) {
         QStringList invArgsLen;
-        foreach (int i, invalidArgsLength)
+        for (int i : qAsConst(invalidArgsLength))
             invArgsLen << QStringLiteral("numArgs == %1").arg(i);
         if (usesNamedArguments && (!ownerClassIsQObject || minArgs > 0))
             s << " else ";
@@ -1923,9 +1939,11 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
         s << INDENT << "Shiboken::setErrorAboutWrongArguments(" << argsVar << ", \"" << funcName << "\", 0);" << endl;
     } else {
         QStringList overloadSignatures;
-        foreach (const AbstractMetaFunction* f, overloadData.overloads()) {
+        const QList<const AbstractMetaFunction *> &overloads = overloadData.overloads();
+        for (const AbstractMetaFunction *f : overloads) {
             QStringList args;
-            foreach(AbstractMetaArgument* arg, f->arguments()) {
+            const AbstractMetaArgumentList &arguments = f->arguments();
+            for (AbstractMetaArgument *arg : arguments)  {
                 QString strArg;
                 AbstractMetaType* argType = arg->type();
                 if (isCString(argType)) {
@@ -2094,9 +2112,10 @@ static void checkTypeViability(const AbstractMetaFunction* func)
 void CppGenerator::writeTypeCheck(QTextStream& s, const OverloadData* overloadData, QString argumentName)
 {
     QSet<const TypeEntry*> numericTypes;
-
-    foreach (OverloadData* od, overloadData->previousOverloadData()->nextOverloadData()) {
-        foreach (const AbstractMetaFunction* func, od->overloads()) {
+    const OverloadDataList &overloads = overloadData->previousOverloadData()->nextOverloadData();
+    for (OverloadData *od : overloads) {
+        const QList<const AbstractMetaFunction *> &odOverloads = od->overloads();
+        for (const AbstractMetaFunction *func : odOverloads) {
             checkTypeViability(func);
             const AbstractMetaType* argType = od->argument(func)->type();
             if (!argType->isPrimitive())
@@ -2269,7 +2288,8 @@ static void addConversionRuleCodeSnippet(CodeSnipList& snippetList, QString& rul
 void CppGenerator::writeConversionRule(QTextStream& s, const AbstractMetaFunction* func, TypeSystem::Language language)
 {
     CodeSnipList snippets;
-    foreach (AbstractMetaArgument* arg, func->arguments()) {
+    const AbstractMetaArgumentList &arguments = func->arguments();
+    for (AbstractMetaArgument *arg : arguments) {
         QString rule = func->conversionRule(language, arg->argumentIndex() + 1);
         addConversionRuleCodeSnippet(snippets, rule, language, TypeSystem::TargetLangCode,
                                      arg->name(), arg->name());
@@ -2331,7 +2351,8 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
     // variable to be used further on this method on the conditional that identifies default
     // method calls.
     if (!hasDefaultCall) {
-        foreach (const AbstractMetaFunction* func, parentOverloadData->overloads()) {
+        const QList<const AbstractMetaFunction *> &overloads = parentOverloadData->overloads();
+        for (const AbstractMetaFunction *func : overloads) {
             if (parentOverloadData->isFinalOccurrence(func)) {
                 referenceFunction = func;
                 hasDefaultCall = true;
@@ -2372,6 +2393,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
     // If the next argument has a default value the decisor can perform a method call;
     // it just need to check if the number of arguments received from Python are equal
     // to the number of parameters preceding the argument with the default value.
+    const OverloadDataList &overloads = parentOverloadData->nextOverloadData();
     if (hasDefaultCall) {
         isFirst = false;
         int numArgs = parentOverloadData->argPos() + 1;
@@ -2379,7 +2401,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
         {
             Indentation indent(INDENT);
             const AbstractMetaFunction* func = referenceFunction;
-            foreach (OverloadData* overloadData, parentOverloadData->nextOverloadData()) {
+            for (OverloadData *overloadData : overloads) {
                 const AbstractMetaFunction* defValFunc = overloadData->getFunctionWithDefaultValue();
                 if (defValFunc) {
                     func = defValFunc;
@@ -2392,7 +2414,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
         s << INDENT << '}';
     }
 
-    foreach (OverloadData* overloadData, parentOverloadData->nextOverloadData()) {
+    for (OverloadData *overloadData : overloads) {
         bool signatureFound = overloadData->overloads().size() == 1
                                 && !overloadData->getFunctionWithDefaultValue()
                                 && !overloadData->findNextArgWithDefault();
@@ -2847,7 +2869,7 @@ void CppGenerator::writeAddPythonToCppConversion(QTextStream& s, const QString&
 
 void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMetaFunction* func, bool usePyArgs)
 {
-    AbstractMetaArgumentList args = OverloadData::getArgumentsWithDefaultValues(func);
+    const AbstractMetaArgumentList &args = OverloadData::getArgumentsWithDefaultValues(func);
     if (args.isEmpty())
         return;
 
@@ -2858,7 +2880,7 @@ void CppGenerator::writeNamedArgumentResolution(QTextStream& s, const AbstractMe
     {
         Indentation indent(INDENT);
         s << INDENT << "PyObject* ";
-        foreach (const AbstractMetaArgument* arg, args) {
+        for (const AbstractMetaArgument *arg : args) {
             int pyArgIndex = arg->argumentIndex() - OverloadData::numberOfRemovedArguments(func, arg->argumentIndex());
             QString pyArgName = usePyArgs
                 ? QString::fromLatin1(PYTHON_ARGS "[%1]").arg(pyArgIndex)
@@ -2933,7 +2955,8 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
 {
     s << INDENT << "// " << func->minimalSignature() << (func->isReverseOperator() ? " [reverse operator]": "") << endl;
     if (func->isConstructor()) {
-        foreach (const CodeSnip &cs, func->injectedCodeSnips()) {
+        const CodeSnipList &snips = func->injectedCodeSnips();
+        for (const CodeSnip &cs : snips) {
             if (cs.position == TypeSystem::CodeSnipPositionEnd) {
                 s << INDENT << "overloadId = " << func->ownerClass()->functions().indexOf(const_cast<AbstractMetaFunction* const>(func)) << ';' << endl;
                 break;
@@ -3228,8 +3251,9 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
     QList<ArgumentModification> ownership_mods;
     // Python object reference management.
     QList<ArgumentModification> refcount_mods;
-    foreach (const FunctionModification &func_mod, func->modifications()) {
-        foreach (const ArgumentModification &arg_mod, func_mod.argument_mods) {
+    const FunctionModificationList &funcMods = func->modifications();
+    for (const FunctionModification &func_mod : funcMods) {
+        for (const ArgumentModification &arg_mod : func_mod.argument_mods) {
             if (!arg_mod.ownerships.isEmpty() && arg_mod.ownerships.contains(TypeSystem::TargetLangCode))
                 ownership_mods.append(arg_mod);
             else if (!arg_mod.referenceCounts.isEmpty())
@@ -3243,7 +3267,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
 
     if (!ownership_mods.isEmpty()) {
         s << endl << INDENT << "// Ownership transferences." << endl;
-        foreach (const ArgumentModification &arg_mod, ownership_mods) {
+        for (const ArgumentModification &arg_mod : qAsConst(ownership_mods)) {
             const AbstractMetaClass* wrappedClass = 0;
             QString pyArgName = argumentNameFromIndex(func, arg_mod.index, &wrappedClass);
             if (!wrappedClass) {
@@ -3274,7 +3298,7 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
         }
 
     } else if (!refcount_mods.isEmpty()) {
-        foreach (const ArgumentModification &arg_mod, refcount_mods) {
+        for (const ArgumentModification &arg_mod : qAsConst(refcount_mods)) {
             ReferenceCount refCount = arg_mod.referenceCounts.first();
             if (refCount.action != ReferenceCount::Set
                 && refCount.action != ReferenceCount::Remove
@@ -3319,15 +3343,15 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
 QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass* metaClass)
 {
     QStringList result;
-    AbstractMetaClassList baseClases = getBaseClasses(metaClass);
+    const AbstractMetaClassList &baseClases = getBaseClasses(metaClass);
     if (!baseClases.isEmpty()) {
-        foreach (const AbstractMetaClass* baseClass, baseClases) {
+        for (const AbstractMetaClass *baseClass : baseClases) {
             result.append(QString::fromLatin1("((size_t) static_cast<const %1*>(class_ptr)) - base")
                                               .arg(baseClass->qualifiedCppName()));
             result.append(QString::fromLatin1("((size_t) static_cast<const %1*>((%2*)((void*)class_ptr))) - base")
                                               .arg(baseClass->qualifiedCppName(), metaClass->qualifiedCppName()));
         }
-        foreach (const AbstractMetaClass* baseClass, baseClases)
+        for (const AbstractMetaClass *baseClass : baseClases)
             result.append(getAncestorMultipleInheritance(baseClass));
     }
     return result;
@@ -3336,7 +3360,7 @@ QStringList CppGenerator::getAncestorMultipleInheritance(const AbstractMetaClass
 void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, const AbstractMetaClass* metaClass)
 {
     QString className = metaClass->qualifiedCppName();
-    QStringList ancestors = getAncestorMultipleInheritance(metaClass);
+    const QStringList ancestors = getAncestorMultipleInheritance(metaClass);
     s << "static int mi_offsets[] = { ";
     for (int i = 0; i < ancestors.size(); i++)
         s << "-1, ";
@@ -3352,7 +3376,7 @@ void CppGenerator::writeMultipleInheritanceInitializerFunction(QTextStream& s, c
         s << INDENT << "const " << className << "* class_ptr = reinterpret_cast<const " << className << "*>(cptr);" << endl;
         s << INDENT << "size_t base = (size_t) class_ptr;" << endl;
 
-        foreach (const QString &ancestor, ancestors)
+        for (const QString &ancestor : ancestors)
             s << INDENT << "offsets.insert(" << ancestor << ");" << endl;
 
         s << endl;
@@ -3380,7 +3404,8 @@ void CppGenerator::writeSpecialCastFunction(QTextStream& s, const AbstractMetaCl
     s << "{\n";
     s << INDENT << className << "* me = reinterpret_cast< ::" << className << "*>(obj);\n";
     bool firstClass = true;
-    foreach (const AbstractMetaClass* baseClass, getAllAncestors(metaClass)) {
+    const AbstractMetaClassList &allAncestors = getAllAncestors(metaClass);
+    for (const AbstractMetaClass *baseClass : allAncestors) {
         s << INDENT << (!firstClass ? "else " : "") << "if (desiredType == reinterpret_cast<SbkObjectType*>(" << cpythonTypeNameExt(baseClass->typeEntry()) << "))\n";
         Indentation indent(INDENT);
         s << INDENT << "return static_cast< ::" << baseClass->qualifiedCppName() << "*>(me);\n";
@@ -3502,7 +3527,7 @@ void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const A
 void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QList<const AbstractMetaClass*>& conversions)
 {
     s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
-    foreach (const AbstractMetaClass* sourceClass, conversions) {
+    for (const AbstractMetaClass *sourceClass : conversions) {
         const QString converterVar = QLatin1String("reinterpret_cast<SbkObjectType *>(")
             + cppApiVariableName(externalType->targetLangPackage()) + QLatin1Char('[')
             + getTypeIndexVariableName(externalType) + QLatin1String("])");
@@ -3557,7 +3582,8 @@ bool CppGenerator::supportsSequenceProtocol(const AbstractMetaClass* metaClass)
 
 bool CppGenerator::shouldGenerateGetSetList(const AbstractMetaClass* metaClass)
 {
-    foreach (AbstractMetaField* f, metaClass->fields()) {
+    const AbstractMetaFieldList &fields = metaClass->fields();
+    for (const AbstractMetaField *f : fields) {
         if (!f->isStatic())
             return true;
     }
@@ -3579,7 +3605,8 @@ void CppGenerator::writeClassDefinition(QTextStream &s,
     className.remove(QRegExp(QLatin1String("_Type$")));
     QString baseClassName(QLatin1Char('0'));
     AbstractMetaFunctionList ctors;
-    foreach (AbstractMetaFunction* f, metaClass->queryFunctions(AbstractMetaClass::Constructors)) {
+    const AbstractMetaFunctionList &allCtors = metaClass->queryFunctions(AbstractMetaClass::Constructors);
+    for (AbstractMetaFunction *f : allCtors) {
         if (!f->isPrivate() && !f->isModifiedRemoved() && !classContext.forSmartPointer())
             ctors.append(f);
     }
@@ -3637,7 +3664,8 @@ void CppGenerator::writeClassDefinition(QTextStream &s,
 
     // search for special functions
     ShibokenGenerator::clearTpFuncs();
-    foreach (AbstractMetaFunction* func, metaClass->functions()) {
+    const AbstractMetaFunctionList &funcs = metaClass->functions();
+    for (AbstractMetaFunction *func : funcs) {
         if (m_tpFuncs.contains(func->name()))
             m_tpFuncs[func->name()] = cpythonFunctionName(func);
     }
@@ -3894,13 +3922,13 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
     nb.insert(QLatin1String("__ixor__"), QString());
     nb.insert(QLatin1String("__ior__"), QString());
 
-    QList<AbstractMetaFunctionList> opOverloads =
+    const QList<AbstractMetaFunctionList> opOverloads =
             filterGroupedOperatorFunctions(metaClass,
                                            AbstractMetaClass::ArithmeticOp
                                            | AbstractMetaClass::LogicalOp
                                            | AbstractMetaClass::BitwiseOp);
 
-    foreach (const AbstractMetaFunctionList &opOverload, opOverloads) {
+    for (const AbstractMetaFunctionList &opOverload : opOverloads) {
         const AbstractMetaFunction* rfunc = opOverload[0];
         QString opName = ShibokenGenerator::pythonOperatorFunctionName(rfunc);
         nb[opName] = cpythonFunctionName(rfunc);
@@ -4139,7 +4167,8 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
     s << INDENT << "switch (op) {" << endl;
     {
         Indentation indent(INDENT);
-        foreach (const AbstractMetaFunctionList &overloads, filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp)) {
+        const QList<AbstractMetaFunctionList> &groupedFuncs = filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp);
+        for (const AbstractMetaFunctionList &overloads : groupedFuncs) {
             const AbstractMetaFunction* rfunc = overloads[0];
 
             QString operatorId = ShibokenGenerator::pythonRichCompareOperatorId(rfunc);
@@ -4151,7 +4180,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
             op = op.right(op.size() - QLatin1String("operator").size());
 
             int alternativeNumericTypes = 0;
-            foreach (const AbstractMetaFunction* func, overloads) {
+            for (const AbstractMetaFunction *func : overloads) {
                 if (!func->isStatic() &&
                     ShibokenGenerator::isNumber(func->arguments()[0]->type()->typeEntry()))
                     alternativeNumericTypes++;
@@ -4159,7 +4188,8 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
 
             bool first = true;
             OverloadData overloadData(overloads, this);
-            foreach (OverloadData* od, overloadData.nextOverloadData()) {
+            const OverloadDataList &nextOverloads = overloadData.nextOverloadData();
+            for (OverloadData *od : nextOverloads) {
                 const AbstractMetaFunction* func = od->referenceFunction();
                 if (func->isStatic())
                     continue;
@@ -4286,7 +4316,7 @@ void CppGenerator::writeEnumsInitialization(QTextStream& s, AbstractMetaEnumList
     if (enums.isEmpty())
         return;
     s << INDENT << "// Initialization of enums." << endl << endl;
-    foreach (const AbstractMetaEnum* cppEnum, enums) {
+    for (const AbstractMetaEnum *cppEnum : qAsConst(enums)) {
         if (cppEnum->isPrivate())
             continue;
         writeEnumInitialization(s, cppEnum);
@@ -4337,7 +4367,8 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
         }
     }
 
-    foreach (const AbstractMetaEnumValue* enumValue, cppEnum->values()) {
+    const AbstractMetaEnumValueList &enumValues = cppEnum->values();
+    for (const AbstractMetaEnumValue *enumValue : enumValues) {
         if (cppEnum->typeEntry()->isEnumValueRejected(enumValue->name()))
             continue;
 
@@ -4396,10 +4427,12 @@ void CppGenerator::writeEnumInitialization(QTextStream& s, const AbstractMetaEnu
 void CppGenerator::writeSignalInitialization(QTextStream& s, const AbstractMetaClass* metaClass)
 {
     // Try to check something and print some warnings
-    foreach (const AbstractMetaFunction* cppSignal, metaClass->cppSignalFunctions()) {
+    const AbstractMetaFunctionList &signalFuncs = metaClass->cppSignalFunctions();
+    for (const AbstractMetaFunction *cppSignal : signalFuncs) {
         if (cppSignal->declaringClass() != metaClass)
             continue;
-        foreach (AbstractMetaArgument* arg, cppSignal->arguments()) {
+        const AbstractMetaArgumentList &arguments = cppSignal->arguments();
+        for (AbstractMetaArgument *arg : arguments) {
             AbstractMetaType* metaType = arg->type();
             const QByteArray origType =
                 QMetaObject::normalizedType(qPrintable(metaType->originalTypeDescription()));
@@ -4632,7 +4665,7 @@ void CppGenerator::writeClassRegister(QTextStream &s,
     if (metaClass->baseClassNames().size() > 1) {
         s << INDENT << "PyObject* " << pyTypeBasesVariable << " = PyTuple_Pack(" << baseClasses.size() << ',' << endl;
         QStringList bases;
-        foreach (const AbstractMetaClass* base, baseClasses)
+        for (const AbstractMetaClass *base : baseClasses)
             bases << QLatin1String("(PyObject*)") + cpythonTypeNameExt(base->typeEntry());
         Indentation indent(INDENT);
         QString separator;
@@ -4726,7 +4759,8 @@ void CppGenerator::writeClassRegister(QTextStream &s,
     }
 
     AbstractMetaEnumList classEnums = metaClass->enums();
-    foreach (AbstractMetaClass* innerClass, metaClass->innerClasses())
+    const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
+    for (AbstractMetaClass *innerClass : innerClasses)
         lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
 
     ErrorCode errorCode(QString::null);
@@ -4736,7 +4770,8 @@ void CppGenerator::writeClassRegister(QTextStream &s,
         writeSignalInitialization(s, metaClass);
 
     // Write static fields
-    foreach (const AbstractMetaField* field, metaClass->fields()) {
+    const AbstractMetaFieldList &fields = metaClass->fields();
+    for (const AbstractMetaField *field : fields) {
         if (!field->isStatic())
             continue;
         s << INDENT << QLatin1String("PyDict_SetItemString(") + cpythonTypeName(metaClass) + QLatin1String(".super.ht_type.tp_dict, \"");
@@ -4796,7 +4831,8 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont
         bool canBeValue = false;
         if (!isObjectType(metaClass)) {
             // check if there's a empty ctor
-            foreach (AbstractMetaFunction* func, metaClass->functions()) {
+            const AbstractMetaFunctionList &funcs = metaClass->functions();
+            for (AbstractMetaFunction *func : funcs) {
                 if (func->isConstructor() && !func->arguments().count()) {
                     canBeValue = true;
                     break;
@@ -4805,7 +4841,7 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont
         }
 
         if (canBeValue) {
-            foreach (const QString &name, nameVariants) {
+            for (const QString &name : qAsConst(nameVariants)) {
                 if (name == QLatin1String("iterator")) {
                     qCWarning(lcShiboken).noquote().nospace()
                          << QString::fromLatin1("%1:%2 FIXME:\n"
@@ -4819,9 +4855,10 @@ void CppGenerator::writeInitQtMetaTypeFunctionBody(QTextStream &s, GeneratorCont
         }
     }
 
-    foreach (AbstractMetaEnum* metaEnum, metaClass->enums()) {
+    const AbstractMetaEnumList &enums = metaClass->enums();
+    for (AbstractMetaEnum *metaEnum : enums) {
         if (!metaEnum->isPrivate() && !metaEnum->isAnonymous()) {
-            foreach (const QString &name, nameVariants)
+            for (const QString &name : qAsConst(nameVariants))
                 s << INDENT << "qRegisterMetaType< ::" << metaEnum->typeEntry()->qualifiedCppName() << " >(\"" << name << "::" << metaEnum->name() << "\");" << endl;
 
             if (metaEnum->typeEntry()->flags()) {
@@ -4849,8 +4886,8 @@ void CppGenerator::writeTypeDiscoveryFunction(QTextStream& s, const AbstractMeta
             s << INDENT << "return cptr;" << endl;
         }
     } else if (metaClass->isPolymorphic()) {
-        AbstractMetaClassList ancestors = getAllAncestors(metaClass);
-        foreach (AbstractMetaClass* ancestor, ancestors) {
+        const AbstractMetaClassList &ancestors = getAllAncestors(metaClass);
+        for (AbstractMetaClass *ancestor : ancestors) {
             if (ancestor->baseClass())
                 continue;
             if (ancestor->isPolymorphic()) {
@@ -4961,7 +4998,8 @@ void CppGenerator::writeGetattroFunction(QTextStream& s, GeneratorContext &conte
             }
             s << INDENT << '}' << endl;
 
-            foreach (const AbstractMetaFunction* func, getMethodsWithBothStaticAndNonStaticMethods(metaClass)) {
+            const AbstractMetaFunctionList &funcs = getMethodsWithBothStaticAndNonStaticMethods(metaClass);
+            for (const AbstractMetaFunction *func : funcs) {
                 QString defName = cpythonMethodDefinitionName(func);
                 s << INDENT << "static PyMethodDef non_static_" << defName << " = {" << endl;
                 {
@@ -5054,7 +5092,7 @@ bool CppGenerator::finishGeneration()
     const FunctionGroupMap &functionGroups = getFunctionGroups();
     for (FunctionGroupMapIt it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
         AbstractMetaFunctionList overloads;
-        foreach (AbstractMetaFunction* func, it.value()) {
+        for (AbstractMetaFunction *func : it.value()) {
             if (!func->isModifiedRemoved()) {
                 overloads.append(func);
                 if (func->typeEntry())
@@ -5084,7 +5122,7 @@ bool CppGenerator::finishGeneration()
     }
     const AbstractMetaClassList lst = classesTopologicalSorted(additionalDependencies);
 
-    foreach (const AbstractMetaClass* cls, lst) {
+    for (const AbstractMetaClass *cls : lst){
         if (!shouldGenerate(cls))
             continue;
 
@@ -5100,7 +5138,8 @@ bool CppGenerator::finishGeneration()
     }
 
     // Initialize smart pointer types.
-    foreach (const AbstractMetaType *metaType, instantiatedSmartPointers()) {
+    const QList<const AbstractMetaType *> &smartPtrs = instantiatedSmartPointers();
+    for (const AbstractMetaType *metaType : smartPtrs) {
         GeneratorContext context(0, metaType, true);
         QString initFunctionName = getInitFunctionName(context);
         s_classInitDecl << "void init_" << initFunctionName << "(PyObject* module);" << endl;
@@ -5134,13 +5173,14 @@ bool CppGenerator::finishGeneration()
     }
 
     s << "#include \"" << getModuleHeaderFileName() << '"' << endl << endl;
-    foreach (const Include& include, includes)
+    for (const Include &include : qAsConst(includes))
         s << include;
     s << endl;
 
     // Global enums
     AbstractMetaEnumList globalEnums = this->globalEnums();
-    foreach (const AbstractMetaClass* metaClass, classes()) {
+    const AbstractMetaClassList &classList = classes();
+    for (const AbstractMetaClass *metaClass : classList) {
         const AbstractMetaClass* encClass = metaClass->enclosingClass();
         if (encClass && encClass->typeEntry()->codeGeneration() != TypeEntry::GenerateForSubclass)
             continue;
@@ -5155,10 +5195,10 @@ bool CppGenerator::finishGeneration()
     QList<Include> extraIncludes;
     if (moduleEntry)
         extraIncludes = moduleEntry->extraIncludes();
-    foreach (AbstractMetaEnum* cppEnum, globalEnums)
+    for (AbstractMetaEnum *cppEnum : qAsConst(globalEnums))
         extraIncludes.append(cppEnum->typeEntry()->extraIncludes());
     qSort(extraIncludes.begin(), extraIncludes.end());
-    foreach (const Include& inc, extraIncludes)
+    for (const Include &inc : qAsConst(extraIncludes))
         s << inc;
     s << endl;
 
@@ -5213,7 +5253,7 @@ bool CppGenerator::finishGeneration()
 
         s << "// Enum definitions ";
         s << "------------------------------------------------------------" << endl;
-        foreach (const AbstractMetaEnum* cppEnum, globalEnums) {
+        for (const AbstractMetaEnum *cppEnum : qAsConst(globalEnums)) {
             if (cppEnum->isAnonymous() || cppEnum->isPrivate())
                 continue;
             writeEnumConverterFunctions(s, cppEnum);
@@ -5229,10 +5269,10 @@ bool CppGenerator::finishGeneration()
         }
     }
 
-    QStringList requiredModules = typeDb->requiredTargetImports();
+    const QStringList &requiredModules = typeDb->requiredTargetImports();
     if (!requiredModules.isEmpty())
         s << "// Required modules' type and converter arrays." << endl;
-    foreach (const QString& requiredModule, requiredModules) {
+    for (const QString &requiredModule : requiredModules) {
         s << "PyTypeObject** " << cppApiVariableName(requiredModule) << ';' << endl;
         s << "SbkConverter** " << convertersVariableName(requiredModule) << ';' << endl;
     }
@@ -5246,7 +5286,7 @@ bool CppGenerator::finishGeneration()
         for (ExtendedConverterData::const_iterator it = extendedConverters.cbegin(), end = extendedConverters.cend(); it != end; ++it) {
             const TypeEntry *externalType = it.key();
             s << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
-            foreach (const AbstractMetaClass* sourceClass, extendedConverters[externalType]) {
+            for (const AbstractMetaClass *sourceClass : it.value()) {
                 AbstractMetaType* sourceType = buildAbstractMetaTypeFromAbstractMetaClass(sourceClass);
                 AbstractMetaType* targetType = buildAbstractMetaTypeFromTypeEntry(externalType);
                 writePythonToCppConversionFunctions(s, sourceType, targetType);
@@ -5254,10 +5294,10 @@ bool CppGenerator::finishGeneration()
         }
     }
 
-    QList<const CustomConversion*> typeConversions = getPrimitiveCustomConversions();
+    const QList<const CustomConversion *> &typeConversions = getPrimitiveCustomConversions();
     if (!typeConversions.isEmpty()) {
         s << endl << "// Primitive Type converters." << endl << endl;
-        foreach (const CustomConversion* conversion, typeConversions) {
+        for (const CustomConversion *conversion : typeConversions) {
             s << "// C++ to Python conversion for type '" << conversion->ownerType()->qualifiedCppName() << "'." << endl;
             writeCppToPythonFunction(s, conversion);
             writeCustomConverterFunctions(s, conversion);
@@ -5265,10 +5305,10 @@ bool CppGenerator::finishGeneration()
         s << endl;
     }
 
-    QList<const AbstractMetaType*> containers = instantiatedContainers();
+    const QList<const AbstractMetaType *> &containers = instantiatedContainers();
     if (!containers.isEmpty()) {
         s << "// Container Type converters." << endl << endl;
-        foreach (const AbstractMetaType* container, containers) {
+        for (const AbstractMetaType *container : containers) {
             s << "// C++ to Python conversion for type '" << container->cppSignature() << "'." << endl;
             writeContainerConverterFunctions(s, container);
         }
@@ -5305,7 +5345,7 @@ bool CppGenerator::finishGeneration()
         s << endl;
     }
 
-    foreach (const QString& requiredModule, typeDb->requiredTargetImports()) {
+    for (const QString& requiredModule : requiredModules) {
         s << INDENT << "{" << endl;
         {
             Indentation indentation(INDENT);
@@ -5347,7 +5387,7 @@ bool CppGenerator::finishGeneration()
 
     if (!typeConversions.isEmpty()) {
         s << endl;
-        foreach (const CustomConversion* conversion, typeConversions) {
+        for (const CustomConversion *conversion : typeConversions) {
             writePrimitiveConverterInitialization(s, conversion);
             s << endl;
         }
@@ -5355,7 +5395,7 @@ bool CppGenerator::finishGeneration()
 
     if (!containers.isEmpty()) {
         s << endl;
-        foreach (const AbstractMetaType* container, containers) {
+        for (const AbstractMetaType *container : containers) {
             writeContainerConverterInitialization(s, container);
             s << endl;
         }
@@ -5372,7 +5412,8 @@ bool CppGenerator::finishGeneration()
     writeEnumsInitialization(s, globalEnums);
 
     s << INDENT << "// Register primitive types converters." << endl;
-    foreach(const PrimitiveTypeEntry* pte, primitiveTypes()) {
+    const QList<const PrimitiveTypeEntry *> &primitiveTypeList = primitiveTypes();
+    for (const PrimitiveTypeEntry *pte : primitiveTypeList) {
         if (!pte->generateCode() || !pte->isCppPrimitive())
             continue;
         const TypeEntry *referencedType = pte->basicReferencedTypeEntry();
@@ -5388,12 +5429,15 @@ bool CppGenerator::finishGeneration()
     }
     // Register type resolver for all containers found in signals.
     QSet<QByteArray> typeResolvers;
-    foreach (AbstractMetaClass* metaClass, classes()) {
+
+    for (AbstractMetaClass *metaClass : classList) {
         if (!metaClass->isQObject() || !metaClass->typeEntry()->generateCode())
             continue;
-        foreach (AbstractMetaFunction* func, metaClass->functions()) {
+        const AbstractMetaFunctionList &functions = metaClass->functions();
+        for (AbstractMetaFunction *func : functions) {
             if (func->isSignal()) {
-                foreach (AbstractMetaArgument* arg, func->arguments()) {
+                const AbstractMetaArgumentList &arguments = func->arguments();
+                for (AbstractMetaArgument *arg : arguments) {
                     if (arg->type()->isContainer()) {
                         QString value = translateType(arg->type(), metaClass, ExcludeConst | ExcludeReference);
                         if (value.startsWith(QLatin1String("::")))
@@ -5431,7 +5475,7 @@ bool CppGenerator::finishGeneration()
     }
 
     if (usePySideExtensions()) {
-        foreach (AbstractMetaEnum* metaEnum, globalEnums)
+        for (AbstractMetaEnum *metaEnum : qAsConst(globalEnums))
             if (!metaEnum->isAnonymous()) {
                 s << INDENT << "qRegisterMetaType< ::" << metaEnum->typeEntry()->qualifiedCppName() << " >(\"" << metaEnum->name() << "\");" << endl;
             }
diff --git a/generator/shiboken2/headergenerator.cpp b/generator/shiboken2/headergenerator.cpp
index ea308f5..95cb426 100644
--- a/generator/shiboken2/headergenerator.cpp
+++ b/generator/shiboken2/headergenerator.cpp
@@ -133,14 +133,16 @@ void HeaderGenerator::generateClass(QTextStream &s, GeneratorContext &classConte
         s << endl << '{' << endl << "public:" << endl;
 
         bool hasVirtualFunction = false;
-        foreach (AbstractMetaFunction *func, filterFunctions(metaClass)) {
+        const AbstractMetaFunctionList &funcs = filterFunctions(metaClass);
+        for (AbstractMetaFunction *func : funcs) {
             if (func->isVirtual())
                 hasVirtualFunction = true;
             writeFunction(s, func);
         }
 
         if (avoidProtectedHack() && metaClass->hasProtectedFields()) {
-            foreach (AbstractMetaField* field, metaClass->fields()) {
+            const AbstractMetaFieldList &fields = metaClass->fields();
+            for (AbstractMetaField *field : fields) {
                 if (!field->isProtected())
                     continue;
                 writeProtectedFieldAccessors(s, field);
@@ -198,7 +200,8 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
             s << func->ownerClass()->qualifiedCppName() << "::";
         s << func->originalName() << '(';
         QStringList args;
-        foreach (const AbstractMetaArgument* arg, func->arguments()) {
+        const AbstractMetaArgumentList &arguments = func->arguments();
+        for (const AbstractMetaArgument *arg : arguments) {
             QString argName = arg->name();
             const TypeEntry* enumTypeEntry = 0;
             if (arg->type()->isFlags())
@@ -234,7 +237,8 @@ void HeaderGenerator::writeFunction(QTextStream& s, const AbstractMetaFunction*
         s << functionSignature(func, QString(), QString(), virtualOption) << ';' << endl;
 
         // Check if this method hide other methods in base classes
-        foreach (const AbstractMetaFunction* f, func->ownerClass()->functions()) {
+        const AbstractMetaFunctionList &ownerFuncs = func->ownerClass()->functions();
+        for (const AbstractMetaFunction *f : ownerFuncs) {
             if (f != func
                 && !f->isConstructor()
                 && !f->isPrivate()
@@ -287,7 +291,8 @@ void HeaderGenerator::writeTypeIndexDefine(QTextStream& s, const AbstractMetaCla
     if (!metaClass->typeEntry()->generateCode())
         return;
     writeTypeIndexDefineLine(s, metaClass->typeEntry());
-    foreach (const AbstractMetaEnum* metaEnum, metaClass->enums()) {
+    const AbstractMetaEnumList &enums = metaClass->enums();
+    for (const AbstractMetaEnum *metaEnum : enums) {
         if (metaEnum->isPrivate())
             continue;
         writeTypeIndexDefineLine(s, metaEnum->typeEntry());
@@ -311,18 +316,20 @@ bool HeaderGenerator::finishGeneration()
 
     macrosStream << "// Type indices" << endl;
     AbstractMetaEnumList globalEnums = this->globalEnums();
-    foreach (const AbstractMetaClass* metaClass, classes()) {
+    const AbstractMetaClassList &classList = classes();
+    for (const AbstractMetaClass *metaClass : classList) {
         writeTypeIndexDefine(macrosStream, metaClass);
         lookForEnumsInClassesNotToBeGenerated(globalEnums, metaClass);
     }
 
-    foreach (const AbstractMetaEnum* metaEnum, globalEnums)
+    for (const AbstractMetaEnum *metaEnum : qAsConst(globalEnums))
         writeTypeIndexDefineLine(macrosStream, metaEnum->typeEntry());
 
     // Write the smart pointer define indexes.
     int smartPointerCountIndex = getMaxTypeIndex();
     int smartPointerCount = 0;
-    foreach (const AbstractMetaType *metaType, instantiatedSmartPointers()) {
+    const QList<const AbstractMetaType *> &instantiatedSmartPtrs = instantiatedSmartPointers();
+    for (const AbstractMetaType *metaType : instantiatedSmartPtrs) {
         QString variableName = getTypeIndexVariableName(metaType);
         macrosStream << "#define ";
         macrosStream.setFieldWidth(60);
@@ -348,9 +355,9 @@ bool HeaderGenerator::finishGeneration()
     // TODO-CONVERTER ------------------------------------------------------------------------------
     // Using a counter would not do, a fix must be made to APIExtractor's getTypeIndex().
     macrosStream << "// Converter indices" << endl;
-    QList<const PrimitiveTypeEntry*> primitives = primitiveTypes();
+    const QList<const PrimitiveTypeEntry *> &primitives = primitiveTypes();
     int pCount = 0;
-    foreach (const PrimitiveTypeEntry* ptype, primitives) {
+    for (const PrimitiveTypeEntry *ptype : primitives) {
         /* Note: do not generate indices for typedef'd primitive types
          * as they'll use the primitive type converters instead, so we
          * don't need to create any other.
@@ -361,7 +368,8 @@ bool HeaderGenerator::finishGeneration()
         _writeTypeIndexDefineLine(macrosStream, getTypeIndexVariableName(ptype), pCount++);
     }
 
-    foreach (const AbstractMetaType* container, instantiatedContainers()) {
+    const QList<const AbstractMetaType *> &containers = instantiatedContainers();
+    for (const AbstractMetaType *container : containers) {
         //_writeTypeIndexDefineLine(macrosStream, getTypeIndexVariableName(container), pCount);
         // DEBUG
         QString variableName = getTypeIndexVariableName(container);
@@ -382,7 +390,7 @@ bool HeaderGenerator::finishGeneration()
     // TODO-CONVERTER ------------------------------------------------------------------------------
 
     macrosStream << "// Macros for type check" << endl;
-    foreach (const AbstractMetaEnum* cppEnum, globalEnums) {
+    for (const AbstractMetaEnum *cppEnum : globalEnums) {
         if (cppEnum->isAnonymous() || cppEnum->isPrivate())
             continue;
         includes << cppEnum->typeEntry()->include();
@@ -390,7 +398,7 @@ bool HeaderGenerator::finishGeneration()
         writeSbkTypeFunction(typeFunctions, cppEnum);
     }
 
-    foreach (AbstractMetaClass* metaClass, classes()) {
+    for (AbstractMetaClass *metaClass : classList) {
         if (!shouldGenerate(metaClass))
             continue;
 
@@ -398,7 +406,8 @@ bool HeaderGenerator::finishGeneration()
         const TypeEntry* classType = metaClass->typeEntry();
         includes << classType->include();
 
-        foreach (const AbstractMetaEnum* cppEnum, metaClass->enums()) {
+        const AbstractMetaEnumList &enums = metaClass->enums();
+        for (const AbstractMetaEnum *cppEnum : enums) {
             if (cppEnum->isAnonymous() || cppEnum->isPrivate())
                 continue;
             EnumTypeEntry* enumType = cppEnum->typeEntry();
@@ -411,7 +420,7 @@ bool HeaderGenerator::finishGeneration()
             writeSbkTypeFunction(typeFunctions, metaClass);
     }
 
-    foreach (const AbstractMetaType *metaType, instantiatedSmartPointers()) {
+    for (const AbstractMetaType *metaType : instantiatedSmartPtrs) {
         const TypeEntry *classType = metaType->typeEntry();
         includes << classType->include();
         writeSbkTypeFunction(typeFunctions, metaType);
@@ -447,25 +456,27 @@ bool HeaderGenerator::finishGeneration()
     QStringList requiredTargetImports = TypeDatabase::instance()->requiredTargetImports();
     if (!requiredTargetImports.isEmpty()) {
         s << "// Module Includes" << endl;
-        foreach (const QString& requiredModule, requiredTargetImports)
+        for (const QString &requiredModule : qAsConst(requiredTargetImports))
             s << "#include <" << getModuleHeaderFileName(requiredModule) << ">" << endl;
         s << endl;
     }
 
     s << "// Binded library includes" << endl;
-    foreach (const Include& include, includes)
+    for (const Include &include : qAsConst(includes))
         s << include;
 
     if (!primitiveTypes().isEmpty()) {
         s << "// Conversion Includes - Primitive Types" << endl;
-        foreach (const PrimitiveTypeEntry* ptype, primitiveTypes())
+        const QList<const PrimitiveTypeEntry*> &primitiveTypeList = primitiveTypes();
+        for (const PrimitiveTypeEntry *ptype : primitiveTypeList)
             s << ptype->include();
         s << endl;
     }
 
     if (!containerTypes().isEmpty()) {
         s << "// Conversion Includes - Container Types" << endl;
-        foreach (const ContainerTypeEntry* ctype, containerTypes())
+        const QList<const ContainerTypeEntry *> &containerTypeList = containerTypes();
+        for (const ContainerTypeEntry *ctype : containerTypeList)
             s << ctype->include();
         s << endl;
     }
@@ -530,13 +541,14 @@ void HeaderGenerator::writeSbkTypeFunction(QTextStream &s, const AbstractMetaTyp
 
 void HeaderGenerator::writeInheritedOverloads(QTextStream& s)
 {
-    foreach (const AbstractMetaFunction* func, m_inheritedOverloads) {
+    for (const AbstractMetaFunction *func : qAsConst(m_inheritedOverloads)) {
         s << INDENT << "inline ";
         s << functionSignature(func, QString(), QString(), Generator::EnumAsInts|Generator::OriginalTypeDescription) << " { ";
         s << (func->type() ? "return " : "");
         s << func->ownerClass()->qualifiedCppName() << "::" << func->originalName() << '(';
         QStringList args;
-        foreach (const AbstractMetaArgument* arg, func->arguments()) {
+        const AbstractMetaArgumentList &arguments = func->arguments();
+        for (const AbstractMetaArgument *arg : arguments) {
             QString argName = arg->name();
             const TypeEntry* enumTypeEntry = 0;
             if (arg->type()->isFlags())
diff --git a/generator/shiboken2/overloaddata.cpp b/generator/shiboken2/overloaddata.cpp
index 8731fe9..d94e1df 100644
--- a/generator/shiboken2/overloaddata.cpp
+++ b/generator/shiboken2/overloaddata.cpp
@@ -53,7 +53,8 @@ static QString getTypeName(const AbstractMetaType* type)
     QString typeName = typeEntry->name();
     if (typeEntry->isContainer()) {
         QStringList types;
-        foreach (const AbstractMetaType* cType, type->instantiations()) {
+        const AbstractMetaTypeList &instantiations = type->instantiations();
+        for (const AbstractMetaType *cType : instantiations) {
             const TypeEntry *typeEntry = getReferencedTypeEntry(cType->typeEntry());
             types << typeEntry->name();
         }
@@ -144,7 +145,8 @@ static QString getImplicitConversionTypeName(const AbstractMetaType* containerTy
         impConv = getTypeName(function->arguments().first()->type());
 
     QStringList types;
-    foreach (const AbstractMetaType* otherType, containerType->instantiations())
+    const AbstractMetaTypeList &instantiations = containerType->instantiations();
+    for (const AbstractMetaType *otherType : instantiations)
         types << (otherType == instantiation ? impConv : getTypeName(otherType));
 
     const ContainerTypeEntry* containerTypeEntry = dynamic_cast<const ContainerTypeEntry*>(containerType->typeEntry());
@@ -209,7 +211,7 @@ void OverloadData::sortNextOverloads()
        << QLatin1String("long");
 
     // sort the children overloads
-    foreach(OverloadData *ov, m_nextOverloadData)
+    for (OverloadData *ov : m_nextOverloadData)
         ov->sortNextOverloads();
 
     if (m_nextOverloadData.size() <= 1)
@@ -218,7 +220,7 @@ void OverloadData::sortNextOverloads()
     // Populates the OverloadSortData object containing map and reverseMap, to map type names to ids,
     // these ids will be used by the topological sort algorithm, because is easier and faster to work
     // with graph sorting using integers.
-    foreach(OverloadData* ov, m_nextOverloadData) {
+    for (OverloadData *ov : m_nextOverloadData) {
         sortData.mapType(ov);
 
         const QString typeName(getTypeName(ov));
@@ -240,7 +242,8 @@ void OverloadData::sortNextOverloads()
             qstringIndex = sortData.lastProcessedItemId();
         }
 
-        foreach (const AbstractMetaType* instantiation, ov->argType()->instantiations()) {
+        const AbstractMetaTypeList &instantiations = ov->argType()->instantiations();
+        for (const AbstractMetaType *instantiation : instantiations) {
             // Add dependencies for type instantiation of container.
             QString typeName = getTypeName(instantiation);
             sortData.mapType(typeName);
@@ -251,10 +254,11 @@ void OverloadData::sortNextOverloads()
             // as Point must come before the PointF instantiation, or else list<Point> will never
             // be called. In the case of primitive types, list<double> must come before list<int>.
             if (instantiation->isPrimitive() && (signedIntegerPrimitives.contains(instantiation->name()))) {
-                foreach (const QString& primitive, nonIntegerPrimitives)
+                for (const QString &primitive : qAsConst(nonIntegerPrimitives))
                     sortData.mapType(getImplicitConversionTypeName(ov->argType(), instantiation, 0, primitive));
             } else {
-                foreach (const AbstractMetaFunction* function, m_generator->implicitConversions(instantiation))
+                const AbstractMetaFunctionList &funcs = m_generator->implicitConversions(instantiation);
+                for (const AbstractMetaFunction *function : funcs)
                     sortData.mapType(getImplicitConversionTypeName(ov->argType(), instantiation, function));
             }
         }
@@ -289,13 +293,14 @@ void OverloadData::sortNextOverloads()
 
     QList<const AbstractMetaFunction *> involvedConversions;
 
-    foreach(OverloadData* ov, m_nextOverloadData) {
+    for (OverloadData *ov : m_nextOverloadData) {
         const AbstractMetaType* targetType = ov->argType();
         const QString targetTypeEntryName(getTypeName(ov));
         int targetTypeId = sortData.map[targetTypeEntryName];
 
         // Process implicit conversions
-        foreach(AbstractMetaFunction* function, m_generator->implicitConversions(targetType)) {
+        const AbstractMetaFunctionList &functions = m_generator->implicitConversions(targetType);
+        for (AbstractMetaFunction *function : functions) {
             QString convertibleType;
             if (function->isConversionOperator())
                 convertibleType = function->ownerClass()->typeEntry()->name();
@@ -320,7 +325,8 @@ void OverloadData::sortNextOverloads()
         // Process inheritance relationships
         if (targetType->isValue() || targetType->isObject()) {
             const AbstractMetaClass *metaClass = AbstractMetaClass::findClass(m_generator->classes(), targetType->typeEntry());
-            foreach (const AbstractMetaClass* ancestor, m_generator->getAllAncestors(metaClass)) {
+            const AbstractMetaClassList &ancestors = m_generator->getAllAncestors(metaClass);
+            for (const AbstractMetaClass *ancestor : ancestors) {
                 QString ancestorTypeName = ancestor->typeEntry()->name();
                 if (!sortData.map.contains(ancestorTypeName))
                     continue;
@@ -331,7 +337,8 @@ void OverloadData::sortNextOverloads()
         }
 
         // Process template instantiations
-        foreach (const AbstractMetaType* instantiation, targetType->instantiations()) {
+        const AbstractMetaTypeList &instantiations = targetType->instantiations();
+        for (const AbstractMetaType *instantiation : instantiations) {
             if (sortData.map.contains(getTypeName(instantiation))) {
                 int convertible = sortData.map[getTypeName(instantiation)];
 
@@ -339,14 +346,15 @@ void OverloadData::sortNextOverloads()
                     graph.addEdge(convertible, targetTypeId);
 
                 if (instantiation->isPrimitive() && (signedIntegerPrimitives.contains(instantiation->name()))) {
-                    foreach (const QString& primitive, nonIntegerPrimitives) {
+                    for (const QString &primitive : qAsConst(nonIntegerPrimitives)) {
                         QString convertibleTypeName = getImplicitConversionTypeName(ov->argType(), instantiation, 0, primitive);
                         if (!graph.containsEdge(targetTypeId, sortData.map[convertibleTypeName])) // Avoid cyclic dependency.
                             graph.addEdge(sortData.map[convertibleTypeName], targetTypeId);
                     }
 
                 } else {
-                    foreach (const AbstractMetaFunction* function, m_generator->implicitConversions(instantiation)) {
+                    const AbstractMetaFunctionList &funcs = m_generator->implicitConversions(instantiation);
+                    for (const AbstractMetaFunction *function : funcs) {
                         QString convertibleTypeName = getImplicitConversionTypeName(ov->argType(), instantiation, function);
                         if (!graph.containsEdge(targetTypeId, sortData.map[convertibleTypeName])) { // Avoid cyclic dependency.
                             graph.addEdge(sortData.map[convertibleTypeName], targetTypeId);
@@ -396,22 +404,22 @@ void OverloadData::sortNextOverloads()
     if (sortData.map.contains(QLatin1String("QString")) && sortData.map.contains(QLatin1String("QByteArray")))
         graph.addEdge(sortData.map[QLatin1String("QString")], sortData.map[QLatin1String("QByteArray")]);
 
-    foreach(OverloadData* ov, m_nextOverloadData) {
+    for (OverloadData *ov : m_nextOverloadData) {
         const AbstractMetaType* targetType = ov->argType();
         if (!targetType->isEnum())
             continue;
 
         QString targetTypeEntryName = getTypeName(targetType);
         // Enum values must precede types implicitly convertible from "int" or "unsigned int".
-        foreach (const QString& implicitFromInt, classesWithIntegerImplicitConversion)
+        for (const QString &implicitFromInt : qAsConst(classesWithIntegerImplicitConversion))
             graph.addEdge(sortData.map[targetTypeEntryName], sortData.map[implicitFromInt]);
     }
 
 
     // Special case for double(int i) (not tracked by m_generator->implicitConversions
-    foreach (const QString& signedIntegerName, signedIntegerPrimitives) {
+    for (const QString &signedIntegerName : qAsConst(signedIntegerPrimitives)) {
         if (sortData.map.contains(signedIntegerName)) {
-            foreach (const QString& nonIntegerName, nonIntegerPrimitives) {
+            for (const QString &nonIntegerName : qAsConst(nonIntegerPrimitives)) {
                 if (sortData.map.contains(nonIntegerName))
                     graph.addEdge(sortData.map[nonIntegerName], sortData.map[signedIntegerName]);
             }
@@ -419,7 +427,7 @@ void OverloadData::sortNextOverloads()
     }
 
     // sort the overloads topologically based on the dependency graph.
-    QLinkedList<int> unmappedResult = graph.topologicalSort();
+    const QLinkedList<int> unmappedResult = graph.topologicalSort();
     if (unmappedResult.isEmpty()) {
         QString funcName = referenceFunction()->name();
         if (referenceFunction()->ownerClass())
@@ -436,7 +444,7 @@ void OverloadData::sortNextOverloads()
     }
 
     m_nextOverloadData.clear();
-    foreach(int i, unmappedResult) {
+    for (int i : unmappedResult) {
         if (!sortData.reverseMap[i])
             continue;
         m_nextOverloadData << sortData.reverseMap[i];
@@ -464,7 +472,7 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib
     : m_minArgs(256), m_maxArgs(0), m_argPos(-1), m_argType(0),
     m_headOverloadData(this), m_previousOverloadData(0), m_generator(generator)
 {
-    foreach (const AbstractMetaFunction* func, overloads) {
+    for (const AbstractMetaFunction *func : overloads) {
         m_overloads.append(func);
         int argSize = func->arguments().size() - numberOfRemovedArguments(func);
         if (m_minArgs > argSize)
@@ -472,7 +480,8 @@ OverloadData::OverloadData(const AbstractMetaFunctionList& overloads, const Shib
         else if (m_maxArgs < argSize)
             m_maxArgs = argSize;
         OverloadData* currentOverloadData = this;
-        foreach (const AbstractMetaArgument* arg, func->arguments()) {
+        const AbstractMetaArgumentList &arguments = func->arguments();
+        for (const AbstractMetaArgument *arg : arguments) {
             if (func->argumentRemoved(arg->argumentIndex() + 1))
                 continue;
             currentOverloadData = currentOverloadData->addOverloadData(func, arg);
@@ -528,7 +537,7 @@ OverloadData* OverloadData::addOverloadData(const AbstractMetaFunction* func,
     const AbstractMetaType* argType = arg->type();
     OverloadData* overloadData = 0;
     if (!func->isOperatorOverload()) {
-        foreach (OverloadData* tmp, m_nextOverloadData) {
+        for (OverloadData *tmp : qAsConst(m_nextOverloadData)) {
             // TODO: 'const char *', 'char *' and 'char' will have the same TypeEntry?
 
             // If an argument have a type replacement, then we should create a new overloaddata
@@ -560,7 +569,7 @@ OverloadData* OverloadData::addOverloadData(const AbstractMetaFunction* func,
 QStringList OverloadData::returnTypes() const
 {
     QSet<QString> retTypes;
-    foreach (const AbstractMetaFunction* func, m_overloads) {
+    for (const AbstractMetaFunction *func : m_overloads) {
         if (!func->typeReplaced(0).isEmpty())
             retTypes << func->typeReplaced(0);
         else if (func->type() && !func->argumentRemoved(0))
@@ -579,7 +588,7 @@ bool OverloadData::hasNonVoidReturnType() const
 
 bool OverloadData::hasVarargs() const
 {
-    foreach (const AbstractMetaFunction* func, m_overloads) {
+    for (const AbstractMetaFunction *func : m_overloads) {
         AbstractMetaArgumentList args = func->arguments();
         if (args.size() > 1 && args.last()->type()->isVarargs())
             return true;
@@ -589,7 +598,7 @@ bool OverloadData::hasVarargs() const
 
 bool OverloadData::hasAllowThread() const
 {
-    foreach (const AbstractMetaFunction* func, m_overloads) {
+    for (const AbstractMetaFunction *func : m_overloads) {
         if (func->allowThread())
             return true;
     }
@@ -598,7 +607,7 @@ bool OverloadData::hasAllowThread() const
 
 bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList& overloads)
 {
-    foreach (const AbstractMetaFunction* func, overloads) {
+    for (const AbstractMetaFunction *func : qAsConst(overloads)) {
         if (func->isStatic())
             return true;
     }
@@ -607,7 +616,7 @@ bool OverloadData::hasStaticFunction(const AbstractMetaFunctionList& overloads)
 
 bool OverloadData::hasStaticFunction() const
 {
-    foreach (const AbstractMetaFunction* func, m_overloads) {
+    for (const AbstractMetaFunction *func : m_overloads) {
         if (func->isStatic())
             return true;
     }
@@ -616,7 +625,7 @@ bool OverloadData::hasStaticFunction() const
 
 bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList& overloads)
 {
-    foreach (const AbstractMetaFunction* func, overloads) {
+    for (const AbstractMetaFunction *func : qAsConst(overloads)) {
         if (!func->isStatic())
             return true;
     }
@@ -625,7 +634,7 @@ bool OverloadData::hasInstanceFunction(const AbstractMetaFunctionList& overloads
 
 bool OverloadData::hasInstanceFunction() const
 {
-    foreach (const AbstractMetaFunction* func, m_overloads) {
+    for (const AbstractMetaFunction *func : m_overloads) {
         if (!func->isStatic())
             return true;
     }
@@ -670,7 +679,8 @@ OverloadDataList OverloadData::overloadDataOnPosition(OverloadData* overloadData
     if (overloadData->argPos() == argPos) {
         overloadDataList.append(overloadData);
     } else if (overloadData->argPos() < argPos) {
-        foreach (OverloadData* pd, overloadData->nextOverloadData())
+        const OverloadDataList &data = overloadData->nextOverloadData();
+        for (OverloadData *pd : data)
             overloadDataList += overloadDataOnPosition(pd, argPos);
     }
     return overloadDataList;
@@ -685,7 +695,7 @@ OverloadDataList OverloadData::overloadDataOnPosition(int argPos) const
 
 bool OverloadData::nextArgumentHasDefaultValue() const
 {
-    foreach (OverloadData* overloadData, m_nextOverloadData) {
+    for (OverloadData *overloadData : m_nextOverloadData) {
         if (overloadData->getFunctionWithDefaultValue())
             return true;
     }
@@ -698,7 +708,8 @@ static OverloadData* _findNextArgWithDefault(OverloadData* overloadData)
         return overloadData;
 
     OverloadData* result = 0;
-    foreach (OverloadData* odata, overloadData->nextOverloadData()) {
+    const OverloadDataList &data = overloadData->nextOverloadData();
+    for (OverloadData *odata : data) {
         OverloadData* tmp = _findNextArgWithDefault(odata);
         if (!result || (tmp && result->argPos() > tmp->argPos()))
             result = tmp;
@@ -713,7 +724,7 @@ OverloadData* OverloadData::findNextArgWithDefault()
 
 bool OverloadData::isFinalOccurrence(const AbstractMetaFunction* func) const
 {
-    foreach (const OverloadData* pd, m_nextOverloadData) {
+    for (const OverloadData *pd : m_nextOverloadData) {
         if (pd->overloads().contains(func))
             return false;
     }
@@ -723,10 +734,10 @@ bool OverloadData::isFinalOccurrence(const AbstractMetaFunction* func) const
 QList<const AbstractMetaFunction*> OverloadData::overloadsWithoutRepetition() const
 {
     QList<const AbstractMetaFunction*> overloads = m_overloads;
-    foreach (const AbstractMetaFunction* func, m_overloads) {
+    for (const AbstractMetaFunction *func : m_overloads) {
         if (func->minimalSignature().endsWith(QLatin1String("const")))
             continue;
-        foreach (const AbstractMetaFunction* f, overloads) {
+        for (const AbstractMetaFunction *f : qAsConst(overloads)) {
             if ((func->minimalSignature() + QLatin1String("const")) == f->minimalSignature()) {
                 overloads.removeOne(f);
                 break;
@@ -738,7 +749,7 @@ QList<const AbstractMetaFunction*> OverloadData::overloadsWithoutRepetition() co
 
 const AbstractMetaFunction* OverloadData::getFunctionWithDefaultValue() const
 {
-    foreach (const AbstractMetaFunction* func, m_overloads) {
+    for (const AbstractMetaFunction *func : m_overloads) {
         int removedArgs = 0;
         for (int i = 0; i <= m_argPos + removedArgs; i++) {
             if (func->argumentRemoved(i + 1))
@@ -754,7 +765,7 @@ QList<int> OverloadData::invalidArgumentLengths() const
 {
     QSet<int> validArgLengths;
 
-    foreach (const AbstractMetaFunction* func, m_headOverloadData->m_overloads) {
+    for (const AbstractMetaFunction *func : qAsConst(m_headOverloadData->m_overloads)) {
         const AbstractMetaArgumentList args = func->arguments();
         int offset = 0;
         for (int i = 0; i < args.size(); ++i) {
@@ -821,7 +832,7 @@ QPair<int, int> OverloadData::getMinMaxArguments(const AbstractMetaFunctionList&
 bool OverloadData::isSingleArgument(const AbstractMetaFunctionList& overloads)
 {
     bool singleArgument = true;
-    foreach (const AbstractMetaFunction* func, overloads) {
+    for (const AbstractMetaFunction *func : overloads) {
         if (func->arguments().size() - numberOfRemovedArguments(func) != 1) {
             singleArgument = false;
             break;
@@ -859,7 +870,7 @@ QString OverloadData::dumpGraph() const
 
         // Shows all function signatures
         s << "legend [fontsize=9 fontname=freemono shape=rect label=\"";
-        foreach (const AbstractMetaFunction* func, overloads()) {
+        for (const AbstractMetaFunction *func : m_overloads) {
             s << "f" << functionNumber(func) << " : ";
             if (func->type())
                 s << toHtml(func->type()->cppSignature());
@@ -893,7 +904,7 @@ QString OverloadData::dumpGraph() const
         s << "</td></tr>";
 
         // Shows type changes for all function signatures
-        foreach (const AbstractMetaFunction* func, overloads()) {
+        for (const AbstractMetaFunction *func : m_overloads) {
             if (func->typeReplaced(0).isEmpty())
                 continue;
             s << "<tr><td bgcolor=\"gray\" align=\"right\">f" << functionNumber(func);
@@ -916,13 +927,13 @@ QString OverloadData::dumpGraph() const
 
         // Overloads for the signature to present point
         s << "<tr><td bgcolor=\"gray\" align=\"right\">overloads</td><td bgcolor=\"gray\" align=\"left\">";
-        foreach (const AbstractMetaFunction* func, overloads())
+        for (const AbstractMetaFunction *func : m_overloads)
             s << 'f' << functionNumber(func) << ' ';
         s << "</td></tr>";
 
         s << "</table>> ];" << endl;
 
-        foreach (const OverloadData* pd, nextOverloadData())
+        for (const OverloadData *pd : m_nextOverloadData)
             s << indent << '"' << rfunc->name() << "\" -> " << pd->dumpGraph();
 
         s << "}" << endl;
@@ -948,12 +959,12 @@ QString OverloadData::dumpGraph() const
 
         // Overloads for the signature to present point
         s << "<tr><td bgcolor=\"gray\" align=\"right\">overloads</td><td bgcolor=\"gray\" align=\"left\">";
-        foreach (const AbstractMetaFunction* func, overloads())
+        for (const AbstractMetaFunction *func : m_overloads)
             s << 'f' << functionNumber(func) << ' ';
         s << "</td></tr>";
 
         // Show default values (original and modified) for various functions
-        foreach (const AbstractMetaFunction* func, overloads()) {
+        for (const AbstractMetaFunction *func : m_overloads) {
             const AbstractMetaArgument* arg = argument(func);
             if (!arg)
                 continue;
@@ -973,7 +984,7 @@ QString OverloadData::dumpGraph() const
 
         s << "</table>>];" << endl;
 
-        foreach (const OverloadData* pd, nextOverloadData())
+        for (const OverloadData *pd : m_nextOverloadData)
             s << indent << argId << " -> " << pd->dumpGraph();
     }
     return result;
@@ -1004,7 +1015,7 @@ bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunctionList& o
 {
     if (OverloadData::getMinMaxArguments(overloads).second == 0)
         return false;
-    foreach (const AbstractMetaFunction* func, overloads) {
+    for (const AbstractMetaFunction *func : overloads) {
         if (hasArgumentWithDefaultValue(func))
             return true;
     }
@@ -1015,7 +1026,7 @@ bool OverloadData::hasArgumentWithDefaultValue() const
 {
     if (maxArgs() == 0)
         return false;
-    foreach (const AbstractMetaFunction* func, overloads()) {
+    for (const AbstractMetaFunction *func : m_overloads) {
         if (hasArgumentWithDefaultValue(func))
             return true;
     }
@@ -1024,7 +1035,8 @@ bool OverloadData::hasArgumentWithDefaultValue() const
 
 bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction* func)
 {
-    foreach (const AbstractMetaArgument* arg, func->arguments()) {
+    const AbstractMetaArgumentList &arguments = func->arguments();
+    for (const AbstractMetaArgument *arg : arguments) {
         if (func->argumentRemoved(arg->argumentIndex() + 1))
             continue;
         if (!ShibokenGenerator::getDefaultValue(func, arg).isEmpty())
@@ -1036,7 +1048,8 @@ bool OverloadData::hasArgumentWithDefaultValue(const AbstractMetaFunction* func)
 AbstractMetaArgumentList OverloadData::getArgumentsWithDefaultValues(const AbstractMetaFunction* func)
 {
     AbstractMetaArgumentList args;
-    foreach (AbstractMetaArgument* arg, func->arguments()) {
+    const AbstractMetaArgumentList &arguments = func->arguments();
+    for (AbstractMetaArgument *arg : arguments) {
         if (ShibokenGenerator::getDefaultValue(func, arg).isEmpty()
             || func->argumentRemoved(arg->argumentIndex() + 1))
             continue;
diff --git a/generator/shiboken2/shibokengenerator.cpp b/generator/shiboken2/shibokengenerator.cpp
index b1edc66..617972c 100644
--- a/generator/shiboken2/shibokengenerator.cpp
+++ b/generator/shiboken2/shibokengenerator.cpp
@@ -243,7 +243,8 @@ bool ShibokenGenerator::shouldGenerateCppWrapper(const AbstractMetaClass* metaCl
         if (!result && metaClass->hasProtectedFunctions()) {
             int protectedFunctions = 0;
             int protectedOperators = 0;
-            foreach (const AbstractMetaFunction* func, metaClass->functions()) {
+            const AbstractMetaFunctionList &funcs = metaClass->functions();
+            for (const AbstractMetaFunction *func : funcs) {
                 if (!func->isProtected() || func->isSignal() || func->isModifiedRemoved())
                     continue;
                 else if (func->isOperatorOverload())
@@ -265,7 +266,8 @@ void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumLi
         return;
 
     if (metaClass->typeEntry()->codeGeneration() == TypeEntry::GenerateForSubclass) {
-        foreach (const AbstractMetaEnum* metaEnum, metaClass->enums()) {
+        const AbstractMetaEnumList &enums = metaClass->enums();
+        for (const AbstractMetaEnum *metaEnum : enums) {
             if (metaEnum->isPrivate() || metaEnum->typeEntry()->codeGeneration() == TypeEntry::GenerateForSubclass)
                 continue;
             if (!enumList.contains(const_cast<AbstractMetaEnum*>(metaEnum)))
@@ -410,9 +412,10 @@ static QString searchForEnumScope(const AbstractMetaClass* metaClass, const QStr
 
     if (!metaClass)
         return QString();
-
-    foreach (const AbstractMetaEnum* metaEnum, metaClass->enums()) {
-        foreach (const AbstractMetaEnumValue* enumValue, metaEnum->values()) {
+    const AbstractMetaEnumList &enums = metaClass->enums();
+    for (const AbstractMetaEnum* metaEnum : enums) {
+        const AbstractMetaEnumValueList &values = metaEnum->values();
+        for (const AbstractMetaEnumValue *enumValue : values) {
             if (enumValueName == enumValue->name())
                 return metaClass->qualifiedCppName();
         }
@@ -479,7 +482,7 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
                 scope.append(QLatin1String("::"));
 
             QStringList fixedEnumItems;
-            foreach (const QString& enumItem, enumItems)
+            for (const QString &enumItem : qAsConst(enumItems))
                 fixedEnumItems << QString(scope + enumItem);
 
             if (!fixedEnumItems.isEmpty()) {
@@ -498,7 +501,8 @@ QString ShibokenGenerator::guessScopeForDefaultValue(const AbstractMetaFunction*
     } else if(arg->type()->isPrimitive()) {
         static QRegExp unknowArgumentRegEx(QLatin1String("^(?:[A-Za-z_][\\w:]*\\()?([A-Za-z_]\\w*)(?:\\))?$")); // [PrimitiveType(] DESIREDNAME [)]
         if (unknowArgumentRegEx.indexIn(value) != -1 && func->implementingClass()) {
-            foreach (const AbstractMetaField* field, func->implementingClass()->fields()) {
+            const AbstractMetaFieldList &fields = func->implementingClass()->fields();
+            for (const AbstractMetaField *field : fields) {
                 if (unknowArgumentRegEx.cap(1).trimmed() == field->name()) {
                     QString fieldName = field->name();
                     if (field->isStatic()) {
@@ -620,8 +624,9 @@ bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFuncti
         return false;
     if (func->argumentRemoved(argIndex + 1))
         return false;
-    foreach (const FunctionModification &funcMod, func->modifications()) {
-        foreach (const ArgumentModification &argMod, funcMod.argument_mods) {
+    const FunctionModificationList &mods = func->modifications();
+    for (const FunctionModification &funcMod : mods) {
+        for (const ArgumentModification &argMod : funcMod.argument_mods) {
             if (argMod.index == argIndex + 1 && argMod.noNullPointers)
                 return true;
         }
@@ -633,7 +638,8 @@ QString ShibokenGenerator::getFormatUnitString(const AbstractMetaFunction* func,
 {
     QString result;
     const char objType = (incRef ? 'O' : 'N');
-    foreach (const AbstractMetaArgument* arg, func->arguments()) {
+    const AbstractMetaArgumentList &arguments = func->arguments();
+    for (const AbstractMetaArgument *arg : arguments) {
         if (func->argumentRemoved(arg->argumentIndex() + 1))
             continue;
 
@@ -1052,7 +1058,8 @@ bool ShibokenGenerator::shouldDereferenceAbstractMetaTypePointer(const AbstractM
 
 bool ShibokenGenerator::visibilityModifiedToPrivate(const AbstractMetaFunction* func)
 {
-    foreach (const FunctionModification &mod, func->modifications()) {
+    const FunctionModificationList &mods = func->modifications();
+    for (const FunctionModification &mod : mods) {
         if (mod.modifiers & Modification::Private)
             return true;
     }
@@ -1443,7 +1450,8 @@ void ShibokenGenerator::writeUnusedVariableCast(QTextStream& s, const QString& v
 AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaClass* metaClass)
 {
     AbstractMetaFunctionList result;
-    foreach (AbstractMetaFunction *func, metaClass->functions()) {
+    const AbstractMetaFunctionList &funcs = metaClass->functions();
+    for (AbstractMetaFunction *func : funcs) {
         if (func->isSignal() || func->isDestructor() || func->usesRValueReferences()
             || (func->isModifiedRemoved() && !func->isAbstract()
                 && (!avoidProtectedHack() || !func->isProtected())))
@@ -1456,11 +1464,13 @@ AbstractMetaFunctionList ShibokenGenerator::filterFunctions(const AbstractMetaCl
 ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverters() const
 {
     ExtendedConverterData extConvs;
-    foreach (const AbstractMetaClass* metaClass, classes()) {
+    const AbstractMetaClassList &classList = classes();
+    for (const AbstractMetaClass *metaClass : classList) {
         // Use only the classes for the current module.
         if (!shouldGenerate(metaClass))
             continue;
-        foreach (AbstractMetaFunction* convOp, metaClass->operatorOverloads(AbstractMetaClass::ConversionOp)) {
+        const AbstractMetaFunctionList &overloads = metaClass->operatorOverloads(AbstractMetaClass::ConversionOp);
+        for (AbstractMetaFunction *convOp : overloads) {
             // Get only the conversion operators that return a type from another module,
             // that are value-types and were not removed in the type system.
             const TypeEntry* convType = convOp->type()->typeEntry();
@@ -1477,7 +1487,8 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter
 QList<const CustomConversion*> ShibokenGenerator::getPrimitiveCustomConversions()
 {
     QList<const CustomConversion*> conversions;
-    foreach (const PrimitiveTypeEntry* type, primitiveTypes()) {
+    const QList<const PrimitiveTypeEntry *> &primitiveTypeList = primitiveTypes();
+    for (const PrimitiveTypeEntry *type : primitiveTypeList) {
         if (!shouldGenerateTypeEntry(type) || !isUserPrimitive(type) || !type->customConversion())
             continue;
 
@@ -1520,7 +1531,7 @@ QString ShibokenGenerator::getCodeSnippets(const CodeSnipList& codeSnips,
 {
     QString code;
     QTextStream c(&code);
-    foreach (const CodeSnip &snip, codeSnips) {
+    for (const CodeSnip &snip : codeSnips) {
         if ((position != TypeSystem::CodeSnipPositionAny && snip.position != position) || !(snip.language & language))
             continue;
         QString snipCode;
@@ -1667,7 +1678,8 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
     }
 
     // Replace %ARG#_TYPE variables.
-    foreach (const AbstractMetaArgument* arg, func->arguments()) {
+    const AbstractMetaArgumentList &arguments = func->arguments();
+    for (const AbstractMetaArgument *arg : arguments) {
         QString argTypeVar = QStringLiteral("%ARG%1_TYPE").arg(arg->argumentIndex() + 1);
         QString argTypeVal = arg->type()->cppSignature();
         code.replace(argTypeVar, argTypeVal);
@@ -1760,17 +1772,17 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
 
     // Replaces template %ARGUMENT_NAMES and %# variables by argument variables and values.
     // Replaces template variables %# for individual arguments.
-    ArgumentVarReplacementList argReplacements = getArgumentReplacement(func, usePyArgs, language, lastArg);
+    const ArgumentVarReplacementList &argReplacements = getArgumentReplacement(func, usePyArgs, language, lastArg);
 
     QStringList args;
-    foreach (const ArgumentVarReplacementPair &pair, argReplacements) {
+    for (const ArgumentVarReplacementPair &pair : argReplacements) {
         if (pair.second.startsWith(QLatin1String(CPP_ARG_REMOVED)))
             continue;
         args << pair.second;
     }
     code.replace(QLatin1String("%ARGUMENT_NAMES"), args.join(QLatin1String(", ")));
 
-    foreach (const ArgumentVarReplacementPair &pair, argReplacements) {
+    for (const ArgumentVarReplacementPair &pair : argReplacements) {
         const AbstractMetaArgument* arg = pair.first;
         int idx = arg->argumentIndex() + 1;
         AbstractMetaType* type = arg->type();
@@ -1809,7 +1821,8 @@ void ShibokenGenerator::writeCodeSnips(QTextStream& s,
         // dispatcher.
         bool hasProtectedOverload = false;
         if (func->isUserAdded()) {
-            foreach (const AbstractMetaFunction* f, getFunctionOverloads(func->ownerClass(), func->name()))
+            const AbstractMetaFunctionList &funcs = getFunctionOverloads(func->ownerClass(), func->name());
+            for (const AbstractMetaFunction *f : funcs)
                 hasProtectedOverload |= f->isProtected();
         }
 
@@ -1975,14 +1988,14 @@ void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVa
         }
         replacements.append(qMakePair(conversionString, conversion));
     }
-    foreach (const StringPair &rep, replacements)
+    for (const StringPair &rep : qAsConst(replacements))
         code.replace(rep.first, rep.second);
 }
 
 bool ShibokenGenerator::injectedCodeUsesCppSelf(const AbstractMetaFunction* func)
 {
     CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode);
-    foreach (const CodeSnip &snip, snips) {
+    for (const CodeSnip &snip : qAsConst(snips)) {
         if (snip.code().contains(QLatin1String("%CPPSELF")))
             return true;
     }
@@ -1992,7 +2005,7 @@ bool ShibokenGenerator::injectedCodeUsesCppSelf(const AbstractMetaFunction* func
 bool ShibokenGenerator::injectedCodeUsesPySelf(const AbstractMetaFunction* func)
 {
     CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::NativeCode);
-    foreach (const CodeSnip &snip, snips) {
+    for (const CodeSnip &snip : qAsConst(snips)) {
         if (snip.code().contains(QLatin1String("%PYSELF")))
             return true;
     }
@@ -2008,7 +2021,7 @@ bool ShibokenGenerator::injectedCodeCallsCppFunction(const AbstractMetaFunction*
         wrappedCtorCall = QStringLiteral("new %1(").arg(wrapperName(func->ownerClass()));
     }
     CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode);
-    foreach (const CodeSnip &snip, snips) {
+    for (const CodeSnip &snip : qAsConst(snips)) {
         if (snip.code().contains(QLatin1String("%FUNCTION_NAME(")) || snip.code().contains(funcCall)
             || (func->isConstructor()
                 && ((func->ownerClass()->isPolymorphic() && snip.code().contains(wrappedCtorCall))
@@ -2023,7 +2036,7 @@ bool ShibokenGenerator::injectedCodeCallsPythonOverride(const AbstractMetaFuncti
 {
     static QRegExp overrideCallRegexCheck(QLatin1String("PyObject_Call\\s*\\(\\s*%PYTHON_METHOD_OVERRIDE\\s*,"));
     CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::NativeCode);
-    foreach (const CodeSnip &snip, snips) {
+    for (const CodeSnip &snip : qAsConst(snips)) {
         if (overrideCallRegexCheck.indexIn(snip.code()) != -1)
             return true;
     }
@@ -2035,7 +2048,7 @@ bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMeta
     static QRegExp retValAttributionRegexCheck_native(QLatin1String("%0\\s*=[^=]\\s*.+"));
     static QRegExp retValAttributionRegexCheck_target(QLatin1String("%PYARG_0\\s*=[^=]\\s*.+"));
     CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, language);
-    foreach (const CodeSnip &snip, snips) {
+    for (const CodeSnip &snip : qAsConst(snips)) {
         if (language == TypeSystem::TargetLangCode) {
             if (retValAttributionRegexCheck_target.indexIn(snip.code()) != -1)
                 return true;
@@ -2050,7 +2063,7 @@ bool ShibokenGenerator::injectedCodeHasReturnValueAttribution(const AbstractMeta
 bool ShibokenGenerator::injectedCodeUsesArgument(const AbstractMetaFunction* func, int argumentIndex)
 {
     CodeSnipList snips = func->injectedCodeSnips(TypeSystem::CodeSnipPositionAny);
-    foreach (const CodeSnip &snip, snips) {
+    for (const CodeSnip &snip : qAsConst(snips)) {
         QString code = snip.code();
         if (code.contains(QLatin1String("%ARGUMENT_NAMES")))
             return true;
@@ -2081,7 +2094,7 @@ bool ShibokenGenerator::classNeedsGetattroFunction(const AbstractMetaClass* meta
     const FunctionGroupMap &functionGroup = getFunctionGroups(metaClass);
     for (FunctionGroupMapIt it = functionGroup.cbegin(), end = functionGroup.cend(); it != end; ++it) {
         AbstractMetaFunctionList overloads;
-        foreach (AbstractMetaFunction* func, it.value()) {
+        for (AbstractMetaFunction *func : qAsConst(it.value())) {
             if (func->isAssignmentOperator() || func->isCastOperator() || func->isModifiedRemoved()
                 || func->isPrivate() || func->ownerClass() != func->implementingClass()
                 || func->isConstructor() || func->isOperatorOverload())
@@ -2112,7 +2125,7 @@ AbstractMetaFunctionList ShibokenGenerator::getMethodsWithBothStaticAndNonStatic
         const FunctionGroupMap &functionGroups = getFunctionGroups(metaClass);
         for (FunctionGroupMapIt it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
             AbstractMetaFunctionList overloads;
-            foreach (AbstractMetaFunction* func, it.value()) {
+            for (AbstractMetaFunction *func : qAsConst(it.value())) {
                 if (func->isAssignmentOperator() || func->isCastOperator() || func->isModifiedRemoved()
                     || func->isPrivate() || func->ownerClass() != func->implementingClass()
                     || func->isConstructor() || func->isOperatorOverload())
@@ -2132,7 +2145,8 @@ AbstractMetaClassList ShibokenGenerator::getBaseClasses(const AbstractMetaClass*
 {
     AbstractMetaClassList baseClasses;
     if (metaClass) {
-        foreach (const QString &parent, metaClass->baseClassNames()) {
+        const QStringList &baseClassNames = metaClass->baseClassNames();
+        for (const QString &parent : baseClassNames) {
             AbstractMetaClass *clazz = AbstractMetaClass::findClass(classes(), parent);
             if (clazz)
                 baseClasses << clazz;
@@ -2155,7 +2169,7 @@ AbstractMetaClassList ShibokenGenerator::getAllAncestors(const AbstractMetaClass
     AbstractMetaClassList result;
     if (metaClass) {
         AbstractMetaClassList baseClasses = getBaseClasses(metaClass);
-        foreach (AbstractMetaClass* base, baseClasses) {
+        for (AbstractMetaClass *base : qAsConst(baseClasses)) {
             result.append(base);
             result.append(getAllAncestors(base));
         }
@@ -2266,7 +2280,7 @@ AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromString(QString typ
         metaType->setReferenceType(refType);
         metaType->setConstant(isConst);
         metaType->setTypeUsagePattern(AbstractMetaType::ContainerPattern);
-        foreach (const QString& instantiation, instantiatedTypes) {
+        for (const QString &instantiation : qAsConst(instantiatedTypes)) {
             AbstractMetaType* tmplArgType = buildAbstractMetaTypeFromString(instantiation);
             metaType->addInstantiation(tmplArgType);
         }
@@ -2301,7 +2315,7 @@ AbstractMetaType* ShibokenGenerator::buildAbstractMetaTypeFromAbstractMetaClass(
 static void dumpFunction(AbstractMetaFunctionList lst)
 {
     qDebug() << "DUMP FUNCTIONS: ";
-    foreach (AbstractMetaFunction *func, lst)
+    for (AbstractMetaFunction *func : qAsConst(lst))
         qDebug() << "*" << func->ownerClass()->name()
                         << func->signature()
                         << "Private: " << func->isPrivate()
@@ -2329,7 +2343,7 @@ QMap< QString, AbstractMetaFunctionList > ShibokenGenerator::getFunctionGroups(c
     AbstractMetaFunctionList lst = scope ? scope->functions() : globalFunctions();
 
     QMap<QString, AbstractMetaFunctionList> results;
-    foreach (AbstractMetaFunction* func, lst) {
+    for (AbstractMetaFunction *func : qAsConst(lst)) {
         if (isGroupable(func))
             results[func->name()].append(func);
     }
@@ -2341,7 +2355,7 @@ AbstractMetaFunctionList ShibokenGenerator::getFunctionOverloads(const AbstractM
     AbstractMetaFunctionList lst = scope ? scope->functions() : globalFunctions();
 
     AbstractMetaFunctionList results;
-    foreach (AbstractMetaFunction* func, lst) {
+    for (AbstractMetaFunction *func : qAsConst(lst)) {
         if (func->name() != functionName)
             continue;
         if (isGroupable(func))
@@ -2357,9 +2371,10 @@ QPair< int, int > ShibokenGenerator::getMinMaxArguments(const AbstractMetaFuncti
 
     int minArgs = std::numeric_limits<int>::max();
     int maxArgs = 0;
-    foreach (const AbstractMetaFunction* func, overloads) {
+    for (const AbstractMetaFunction* func : qAsConst(overloads)) {
         int numArgs = 0;
-        foreach (const AbstractMetaArgument* arg, func->arguments()) {
+        const AbstractMetaArgumentList &arguments = func->arguments();
+        for (const AbstractMetaArgument *arg : arguments) {
             if (!func->argumentRemoved(arg->argumentIndex() + 1))
                 numArgs++;
         }
@@ -2389,7 +2404,7 @@ QMap<QString, QString> ShibokenGenerator::options() const
 
 static void getCode(QStringList& code, const CodeSnipList& codeSnips)
 {
-    foreach (const CodeSnip& snip, codeSnips)
+    for (const CodeSnip &snip : qAsConst(codeSnips))
         code.append(snip.code());
 }
 
@@ -2408,7 +2423,7 @@ static void getCode(QStringList& code, const TypeEntry* type)
     if (toCppConversions.isEmpty())
         return;
 
-    foreach (CustomConversion::TargetToNativeConversion* toNative, toCppConversions)
+    for (CustomConversion::TargetToNativeConversion *toNative : qAsConst(toCppConversions))
         code.append(toNative->conversion());
 }
 
@@ -2423,20 +2438,23 @@ bool ShibokenGenerator::doSetup(const QMap<QString, QString>& args)
 
     TypeDatabase* td = TypeDatabase::instance();
     QStringList snips;
-    foreach (const PrimitiveTypeEntry* type, primitiveTypes())
+    const QList<const PrimitiveTypeEntry *> &primitiveTypeList = primitiveTypes();
+    for (const PrimitiveTypeEntry *type : primitiveTypeList)
         getCode(snips, type);
-    foreach (const ContainerTypeEntry* type, containerTypes())
+    const QList<const ContainerTypeEntry *> &containerTypeList = containerTypes();
+    for (const ContainerTypeEntry *type : containerTypeList)
         getCode(snips, type);
-    foreach (const AbstractMetaClass* metaClass, classes())
+    const AbstractMetaClassList &classList = classes();
+    for (const AbstractMetaClass *metaClass : classList)
         getCode(snips, metaClass->typeEntry());
     getCode(snips, td->findType(packageName()));
     const FunctionGroupMap &functionGroups = getFunctionGroups();
     for (FunctionGroupMapIt it = functionGroups.cbegin(), end = functionGroups.cend(); it != end; ++it) {
-        foreach (AbstractMetaFunction* func, it.value())
+        for (AbstractMetaFunction *func : it.value())
             getCode(snips, func->injectedCodeSnips());
     }
 
-    foreach (const QString& code, snips) {
+    for (const QString &code : qAsConst(snips)) {
         collectContainerTypesFromConverterMacros(code, true);
         collectContainerTypesFromConverterMacros(code, false);
     }
@@ -2506,7 +2524,8 @@ QString ShibokenGenerator::convertersVariableName(const QString& moduleName) con
 static QString processInstantiationsVariableName(const AbstractMetaType* type)
 {
     QString res = QLatin1Char('_') + _fixedCppTypeName(type->typeEntry()->qualifiedCppName()).toUpper();
-    foreach (const AbstractMetaType* instantiation, type->instantiations()) {
+    const AbstractMetaTypeList &instantiations = type->instantiations();
+    for (const AbstractMetaType  *instantiation : instantiations) {
         res += instantiation->isContainer()
                ? processInstantiationsVariableName(instantiation)
                : QLatin1Char('_') + _fixedCppTypeName(instantiation->cppSignature()).toUpper();
@@ -2521,7 +2540,8 @@ QString ShibokenGenerator::getTypeIndexVariableName(const AbstractMetaClass* met
             return QString();
         QString base = _fixedCppTypeName(templateBaseClass->typeEntry()->qualifiedCppName()).toUpper();
         QString instantiations;
-        foreach (const AbstractMetaType* instantiation, metaClass->templateBaseClassInstantiations())
+        const AbstractMetaTypeList &templateBaseClassInstantiations = metaClass->templateBaseClassInstantiations();
+        for (const AbstractMetaType *instantiation : templateBaseClassInstantiations)
             instantiations += processInstantiationsVariableName(instantiation);
         return QString::fromLatin1("SBK_%1%2_IDX").arg(base, instantiations);
     }
@@ -2585,8 +2605,9 @@ QString  ShibokenGenerator::getDefaultValue(const AbstractMetaFunction* func, co
         return arg->defaultValueExpression();
 
     //Check modifications
-    foreach(FunctionModification  m, func->modifications()) {
-        foreach(ArgumentModification am, m.argument_mods) {
+    const FunctionModificationList &mods = func->modifications();
+    for (const FunctionModification &m : mods) {
+        for (const ArgumentModification &am : m.argument_mods) {
             if (am.index == (arg->argumentIndex() + 1))
                 return am.replacedDefaultExpression;
         }
diff --git a/tests/test_generator/dummygenerator.cpp b/tests/test_generator/dummygenerator.cpp
index 51d2b33..40d9fb7 100644
--- a/tests/test_generator/dummygenerator.cpp
+++ b/tests/test_generator/dummygenerator.cpp
@@ -52,7 +52,8 @@ DummyGenerator::doSetup(const QMap<QString, QString>& args)
         QFile logFile(args["dump-arguments"]);
         logFile.open(QIODevice::WriteOnly | QIODevice::Text);
         QTextStream out(&logFile);
-        foreach (const QString& key, args.keys()) {
+        for (QMap<QString, QString>::const_iterator it = args.cbegin(), end = args.cend(); it != end; ++it) {
+            const QString& key = it.key();
             if (key == "arg-1")
                 out << "header-file";
             else if (key == "arg-2")