REF: Replace Q_FOREACH with range-based for loops

hjmjohnson · hjmjohnson · commit f0c4ee6cb53b · 2025-06-27T06:59:03.000-04:00
The use of Q_FOREACH is deprecated.

Replaced instances of `foreach` with range-based `for`
loops for modernization and code consistency.
diff --git a/examples/PyLauncher/main.cpp b/examples/PyLauncher/main.cpp
@@ -78,7 +78,7 @@ int main( int argc, char **argv )
   }
   PythonQtScriptingConsole console(NULL, mainContext);
 
-  Q_FOREACH(QString file, files) {
+  for( QString file :  files ) {
     mainContext.evalFile(file);
   }
   if (showConsole || console.hadError()) {
diff --git a/generator/setupgenerator.cpp b/generator/setupgenerator.cpp
@@ -182,7 +182,7 @@ static void addListRegistration(AbstractMetaType::shared_pointer type, QSet<QStr
     
     /*
     QString debugStr;
-    Q_FOREACH(AbstractMetaType* arg, args) {
+    for( AbstractMetaType* arg :  args ) {
       debugStr += QString(arg->typeEntry()->isEnum()?"ENUM ":"") + arg->typeEntry()->qualifiedCppName() + ",";
       if (arg->typeEntry()->qualifiedCppName() == "QPair") {
         debugStr += "(" + arg->instantiations().at(0)->typeEntry()->qualifiedCppName() + ",";
diff --git a/generator/shellimplgenerator.cpp b/generator/shellimplgenerator.cpp
@@ -88,7 +88,7 @@ void ShellImplGenerator::write(QTextStream &s, const AbstractMetaClass *meta_cla
 
   IncludeList list = meta_class->typeEntry()->extraIncludes();
   std::sort(list.begin(), list.end());
-  foreach (const Include &inc, list) {
+  for (const Include &inc : list) {
     ShellGenerator::writeInclude(s, inc);
   }  
   s << endl;
@@ -122,7 +122,7 @@ void ShellImplGenerator::write(QTextStream &s, const AbstractMetaClass *meta_cla
     s << "}" << endl;
 
     AbstractMetaFunctionList virtualsForShell = getVirtualFunctionsForShell(meta_class);
-    foreach (const AbstractMetaFunction *fun, virtualsForShell) {
+    for (const AbstractMetaFunction *fun : virtualsForShell) {
       bool hasReturnValue = !fun->type().isNull();
       writeFunctionSignature(s, fun, meta_class, QString(),
         Option(ShowStatic | UnderscoreSpaces | UseIndexedName),
@@ -141,7 +141,7 @@ void ShellImplGenerator::write(QTextStream &s, const AbstractMetaClass *meta_cla
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
         s << "    static PyObject* name = PyUnicode_FromString(\"" << fun->name() << "\");" << endl;
 #else
-        s << "    static PyObject* name = PyString_FromString(\"" << fun->name() << "\");" << endl;
+        s << "    static PyObject* name = PyUnicode_FromString(\"" << fun->name() << "\");" << endl;
 #endif
         s << "    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);" << endl;
         s << "    if (obj) {" << endl;
@@ -238,7 +238,7 @@ void ShellImplGenerator::write(QTextStream &s, const AbstractMetaClass *meta_cla
   if (meta_class->generateShellClass() || !meta_class->isAbstract()) {
 
     // write constructors
-    foreach (const AbstractMetaFunction *ctor, ctors) {
+    for (const AbstractMetaFunction *ctor : ctors) {
       if (ctor->isAbstract() || (!meta_class->generateShellClass() && !ctor->isPublic())) { continue; }
 
       s << meta_class->qualifiedCppName() << "* ";
diff --git a/src/PythonQt.cpp b/src/PythonQt.cpp
@@ -1540,7 +1540,7 @@ void PythonQtPrivate::setupSharedLibrarySuffixes()
   _sharedLibrarySuffixes << "_d.so";
   #endif
 #endif
-  Q_FOREACH (QVariant entry, result.toList()) {
+  for( QVariant entry :  result.toList( )) {
     QVariantList suffixEntry = entry.toList();
     if (suffixEntry.count()==3) {
       int code = suffixEntry.at(2).toInt();
@@ -1609,7 +1609,7 @@ void PythonQtPrivate::addDecorators(QObject* o, int decoTypes)
 
 void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)
 {
-  Q_FOREACH(QString name, names) {
+  for( QString name :  names ) {
     _knownQObjectClassNames.insert(name.toUtf8(), true);
   }
 }
@@ -1624,7 +1624,7 @@ void PythonQt::removeSignalHandlers()
   QList<PythonQtSignalReceiver*> signalReceivers = _p->_signalReceivers.values();
 
   // just delete all signal receivers, they will remove themselves via removeSignalEmitter()
-  foreach(PythonQtSignalReceiver* receiver, signalReceivers) {
+  for(PythonQtSignalReceiver* receiver : signalReceivers) {
     delete receiver;
   }
   // just to be sure, clear the receiver map as well
@@ -2162,7 +2162,7 @@ PyObject* PythonQt::helpCalled(PythonQtClassInfo* info)
 
 void PythonQt::clearNotFoundCachedMembers()
 {
-  Q_FOREACH(PythonQtClassInfo* info, _p->_knownClassInfos) {
+  for( PythonQtClassInfo* info :  _p->_knownClassInfos ) {
     info->clearNotFoundCachedMembers();
   }
 }
diff --git a/src/PythonQtClassInfo.cpp b/src/PythonQtClassInfo.cpp
@@ -86,7 +86,7 @@ PythonQtClassInfo::~PythonQtClassInfo()
   if (_destructor) {
     _destructor->deleteOverloadsAndThis();
   }
-  Q_FOREACH(PythonQtSlotInfo* info, _decoratorSlots) {
+  for( PythonQtSlotInfo* info :  _decoratorSlots ) {
     info->deleteOverloadsAndThis();
   }
 }
@@ -178,7 +178,7 @@ bool PythonQtClassInfo::lookForPropertyAndCache(const char* memberName)
 PythonQtSlotInfo* PythonQtClassInfo::recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset)
 {
   inputInfo = findDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset);
-  Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+  for( const ParentClassInfo& info :  _parentClasses ) {
     inputInfo = info._parent->recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset+info._upcastingOffset);
   }
   return inputInfo;
@@ -330,7 +330,7 @@ PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)
         // look for dynamic decorators in this class and in derived classes
         QList<QObject*> decoObjects;
         recursiveCollectDecoratorObjects(decoObjects);
-        Q_FOREACH(QObject* deco, decoObjects) {
+        for( QObject* deco :  decoObjects ) {
           // call on ourself for caching, but with different metaObject():
           found = lookForEnumAndCache(deco->metaObject(), memberName);
           if (found) {
@@ -349,7 +349,7 @@ PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)
         found = true;
       }
       // maybe it is a nested class?
-      Q_FOREACH(PythonQtClassInfo* nestedClass, _nestedClasses) {
+      for( PythonQtClassInfo* nestedClass :  _nestedClasses ) {
         PyObject* pyClass = nestedClass->pythonQtClassWrapper();
         if (pyClass) {
           if (strcmp(memberName, nestedClass->unscopedClassName().constData()) == 0) {
@@ -391,14 +391,14 @@ void PythonQtClassInfo::recursiveCollectDecoratorObjects(QList<QObject*>& decora
   if (deco) {
     decoratorObjects.append(deco);
   }
-  Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+  for( const ParentClassInfo& info :  _parentClasses ) {
     info._parent->recursiveCollectDecoratorObjects(decoratorObjects);
   }
 }
 
 void PythonQtClassInfo::recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects) {
   classInfoObjects.append(this);
-  Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+  for( const ParentClassInfo& info :  _parentClasses ) {
     info._parent->recursiveCollectClassInfos(classInfoObjects);
   }
 }
@@ -493,7 +493,7 @@ QStringList PythonQtClassInfo::propertyList()
     }
   }
   QStringList members = memberList();
-  foreach(QString member, members) {
+  for(const QString& member : members) {
     if (member.startsWith("py_get_")) {
       l << member.mid(7);
     }
@@ -524,7 +524,7 @@ QStringList PythonQtClassInfo::memberList()
     // look for dynamic decorators in this class and in derived classes
     QList<PythonQtClassInfo*> infos;
     recursiveCollectClassInfos(infos);
-    Q_FOREACH(PythonQtClassInfo* info, infos) {
+    for( PythonQtClassInfo* info :  infos ) {
       info->listDecoratorSlotsFromDecoratorProvider(l, false);
     }
   }
@@ -537,11 +537,11 @@ QStringList PythonQtClassInfo::memberList()
   // check enums in the class hierachy of CPP classes
   QList<QObject*> decoObjects;
   recursiveCollectDecoratorObjects(decoObjects);
-  Q_FOREACH(QObject* deco, decoObjects) {
+  for( QObject* deco :  decoObjects ) {
     enumMetaObjects << deco->metaObject();
   }
   
-  Q_FOREACH(const QMetaObject* meta, enumMetaObjects) {
+  for( const QMetaObject* meta :  enumMetaObjects ) {
     for (int i = 0; i<meta->enumeratorCount(); i++) {
       QMetaEnum e = meta->enumerator(i);
       l << e.name();
@@ -554,7 +554,7 @@ QStringList PythonQtClassInfo::memberList()
     }
   }
 
-  Q_FOREACH(PythonQtClassInfo* nestedClass, _nestedClasses) {
+  for( PythonQtClassInfo* nestedClass :  _nestedClasses ) {
     PyObject* pyClass = nestedClass->pythonQtClassWrapper();
     if (pyClass) {
       QByteArray name = nestedClass->unscopedClassName();
@@ -583,7 +583,7 @@ void* PythonQtClassInfo::castTo(void* ptr, const char* classname)
   if (_wrappedClassName == classname) {
     return ptr;
   }
-  Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+  for( const ParentClassInfo& info :  _parentClasses ) {
     void* result = info._parent->castTo((char*)ptr + info._upcastingOffset, classname);
     if (result) {
       return result;
@@ -597,7 +597,7 @@ bool PythonQtClassInfo::inherits(const char* name)
   if (_wrappedClassName == name) {
     return true;
   }
-  Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+  for( const ParentClassInfo& info :  _parentClasses ) {
     if (info._parent->inherits(name)) {
       return true;
     }
@@ -610,7 +610,7 @@ bool PythonQtClassInfo::inherits(PythonQtClassInfo* classInfo)
   if (classInfo == this) {
     return true;
   }
-  Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+  for( const ParentClassInfo& info :  _parentClasses ) {
     if (info._parent->inherits(classInfo)) {
       return true;
     }
@@ -767,14 +767,14 @@ QObject* PythonQtClassInfo::decorator()
 void* PythonQtClassInfo::recursiveCastDownIfPossible(void* ptr, const char** resultClassName)
 {
   if (!_polymorphicHandlers.isEmpty()) {
-    Q_FOREACH(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {
+    for( PythonQtPolymorphicHandlerCB* cb :  _polymorphicHandlers ) {
       void* resultPtr = (*cb)(ptr, resultClassName);
       if (resultPtr) {
         return resultPtr;
       }
     }
   }
-  Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+  for( const ParentClassInfo& info :  _parentClasses ) {
     if (!info._parent->isQObject()) {
       void* resultPtr = info._parent->recursiveCastDownIfPossible((char*)ptr + info._upcastingOffset, resultClassName);
       if (resultPtr) {
@@ -818,7 +818,7 @@ void* PythonQtClassInfo::castDownIfPossible(void* ptr, PythonQtClassInfo** resul
   // we only do downcasting on the base object, not on the whole inheritance tree...
   void* resultPtr = nullptr;
   if (!_polymorphicHandlers.isEmpty()) {
-    Q_FOREACH(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {
+    for( PythonQtPolymorphicHandlerCB* cb :  _polymorphicHandlers ) {
       resultPtr = (*cb)(ptr, &className);
       if (resultPtr) {
         break;
@@ -897,7 +897,7 @@ void PythonQtClassInfo::createEnumWrappers(const QObject* decoratorProvider)
     if (decoratorProvider) {
       createEnumWrappers(decoratorProvider->metaObject());
     }
-    Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+    for( const ParentClassInfo& info :  _parentClasses ) {
       // trigger decorator() instead of createEnumWrappers(),
       // which will then call createEnumWrappers().
       info._parent->decorator();
@@ -912,13 +912,13 @@ PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {
     // which will then call createEnumWrappers().
     decorator();
   }
-  Q_FOREACH(const PythonQtObjectPtr& p, _enumWrappers) {
+  for( const PythonQtObjectPtr& p :  _enumWrappers ) {
     const char* className = ((PyTypeObject*)p.object())->tp_name;
     if (qstrcmp(className, name)==0) {
       return p.object();
     }
   }
-  Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
+  for( const ParentClassInfo& info :  _parentClasses ) {
     PyObject* p = info._parent->findEnumWrapper(name);
     if (p) return p;
   }
diff --git a/src/PythonQtClassWrapper.cpp b/src/PythonQtClassWrapper.cpp
@@ -484,7 +484,7 @@ static PyObject *PythonQtClassWrapper_getattro(PyObject *obj, PyObject *name)
     QSet<QString> completeSet = QSet<QString>::fromList(members);
     completeSet.unite(QSet<QString>::fromList(properties));
 #endif
-    Q_FOREACH (QString name, completeSet) {
+    for( QString name :  completeSet ) {
       if (name.startsWith("py_")) {
         // do not expose internal slots
         continue;
diff --git a/src/PythonQtConversion.cpp b/src/PythonQtConversion.cpp
@@ -1365,8 +1365,8 @@ PyObject* PythonQtConv::QStringListToPyObject(const QStringList& list)
 {
   PyObject* result = PyTuple_New(list.count());
   int i = 0;
-  QString str;
-  Q_FOREACH (str, list) {
+
+  for( QString str :  list ) {
     PyTuple_SET_ITEM(result, i, PythonQtConv::QStringToPyObject(str));
     i++;
   }
@@ -1432,8 +1432,7 @@ PyObject* PythonQtConv::QVariantHashToPyObject(const QVariantHash& m) {
 PyObject* PythonQtConv::QVariantListToPyObject(const QVariantList& l) {
   PyObject* result = PyTuple_New(l.count());
   int i = 0;
-  QVariant v;
-  Q_FOREACH (v, l) {
+  for( QVariant v :  l ) {
     PyTuple_SET_ITEM(result, i, PythonQtConv::QVariantToPyObject(v));
     i++;
   }
@@ -1446,7 +1445,7 @@ PyObject* PythonQtConv::ConvertQListOfPointerTypeToPythonList(QList<void*>* list
 {
   PyObject* result = PyTuple_New(list->count());
   int i = 0;
-  Q_FOREACH (void* value, *list) {
+  for( void* value :  *list ) {
     PyObject* wrap = PythonQt::priv()->wrapPtr(value, info.innerName);
     if (wrap) {
       PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)wrap;
diff --git a/src/PythonQtConversion.h b/src/PythonQtConversion.h
@@ -243,7 +243,7 @@ PyObject* PythonQtConvertListOfValueTypeToPythonList(const void* /*QList<T>* */
   }
   PyObject* result = PyTuple_New(list->size());
   int i = 0;
-  Q_FOREACH (const T& value, *list) {
+  for( const T& value :  *list ) {
     PyTuple_SET_ITEM(result, i, PythonQtConv::convertQtValueToPythonInternal(innerType, &value));
     i++;
   }
@@ -293,7 +293,7 @@ PyObject* PythonQtConvertListOfKnownClassToPythonList(const void* /*QList<T>* */
   }
   PyObject* result = PyTuple_New(list->size());
   int i = 0;
-  Q_FOREACH(const T& value, *list) {
+  for( const T& value :  *list ) {
     T* newObject = new T(value);
     PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)PythonQt::priv()->wrapPtr(newObject, innerType->className());
     wrap->_ownedByPythonQt = true;
@@ -423,7 +423,7 @@ PyObject* PythonQtConvertListOfPairToPythonList(const void* /*QList<QPair<T1,T2>
   PyObject* result = PyTuple_New(list->size());
   int i = 0;
   typedef const QPair<T1, T2> Pair;
-  Q_FOREACH(Pair& value, *list) {
+  for( Pair& value :  *list ) {
     PyObject* object = PythonQtConvertPairToPython<T1, T2>(&value, innerType);
     PyTuple_SET_ITEM(result, i, object);
     i++;
diff --git a/src/PythonQtImporter.cpp b/src/PythonQtImporter.cpp
@@ -101,7 +101,7 @@ PythonQtImport::ModuleInfo PythonQtImport::getModuleInfo(PythonQtImporter* self,
 
   QString test;
   // test if it is a shared library (they have precedence over *.py files and this is used in eggs)
-  Q_FOREACH(const QString& suffix, PythonQt::priv()->sharedLibrarySuffixes()) {
+  for( const QString& suffix :  PythonQt::priv( )->sharedLibrarySuffixes()) {
     test = path + suffix;
     if (PythonQt::importInterface()->exists(test)) {
       info.fullPath = test;
@@ -143,7 +143,7 @@ int PythonQtImporter_init(PythonQtImporter *self, PyObject *args, PyObject * /*k
       return -1;
     } else {
       const QStringList& ignorePaths = PythonQt::self()->getImporterIgnorePaths();
-      Q_FOREACH(QString ignorePath, ignorePaths) {
+      for( QString ignorePath :  ignorePaths ) {
         if (path.startsWith(ignorePath)) {
           PyErr_SetString(PythonQtImportError,
             "path ignored");
diff --git a/src/PythonQtInstanceWrapper.cpp b/src/PythonQtInstanceWrapper.cpp
@@ -390,7 +390,7 @@ static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
     if (wrapper->_obj) {
       // we need to replace the properties with their real values...
       QStringList l = wrapper->classInfo()->propertyList();
-      Q_FOREACH (QString name, l) {
+      for( QString name :  l ) {
         PyObject* o = PyObject_GetAttrString(obj, QStringToPythonConstCharPointer(name));
         if (o) {
           PyDict_SetItemString(dict, QStringToPythonConstCharPointer(name), o);
@@ -401,7 +401,7 @@ static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
       }
 
       QList<QByteArray> dynamicProps = wrapper->_obj->dynamicPropertyNames();
-      Q_FOREACH (QByteArray name, dynamicProps) {
+      for( QByteArray name :  dynamicProps ) {
         PyObject* o = PyObject_GetAttrString(obj, name.data());
         if (o) {
           PyDict_SetItemString(dict, name.data(), o);
diff --git a/src/PythonQtMethodInfo.cpp b/src/PythonQtMethodInfo.cpp
@@ -62,7 +62,7 @@ PythonQtMethodInfo::PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInf
   fillParameterInfo(type, QByteArray(meta.typeName()), classInfo);
   _parameters.append(type);
   QList<QByteArray> names = meta.parameterTypes();
-  Q_FOREACH (const QByteArray& name, names) {
+  for( const QByteArray& name :  names ) {
     fillParameterInfo(type, name, classInfo);
     _parameters.append(type);
   }
@@ -75,7 +75,7 @@ PythonQtMethodInfo::PythonQtMethodInfo(const QByteArray& typeName, const QList<Q
   ParameterInfo type;
   fillParameterInfo(type, typeName, nullptr);
   _parameters.append(type);
-  Q_FOREACH (const QByteArray& name, args) {
+  for( const QByteArray& name :  args ) {
     fillParameterInfo(type, name, nullptr);
     _parameters.append(type);
   }
@@ -622,7 +622,7 @@ QStringList PythonQtSlotInfo::overloads(bool skipReturnValue) const
     }
     if (slotsWithSameArgs.size() > 1) {
       results << maxArgSlot->fullSignature(skipReturnValue, minSameArgs);
-      foreach(const PythonQtSlotInfo* o, slotsWithSameArgs) {
+      for(const PythonQtSlotInfo* o : slotsWithSameArgs) {
         list.removeOne(o);
       }
     } else {
diff --git a/src/gui/PythonQtScriptingConsole.cpp b/src/gui/PythonQtScriptingConsole.cpp
@@ -300,7 +300,7 @@ void PythonQtScriptingConsole::handleTabCompletion()
     compareText = compareText.toLower();
     QStringList found;
     QStringList l = PythonQt::self()->introspection(_context, lookup, PythonQt::Anything);
-    Q_FOREACH (QString n, l) {
+    for( QString n :  l ) {
       if (n.toLower().startsWith(compareText)) {
         found << n;
       }
diff --git a/tests/PythonQtTests.cpp b/tests/PythonQtTests.cpp

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ int main( int argc, char **argv )`
`78`	`78`	`}`
`79`	`79`	`PythonQtScriptingConsole console(NULL, mainContext);`
`80`	`80`
`81`		`- Q_FOREACH(QString file, files) {`
	`81`	`+ for( QString file : files ) {`
`82`	`82`	`mainContext.evalFile(file);`
`83`	`83`	`}`
`84`	`84`	`if (showConsole \|\| console.hadError()) {`
Original file line number	Diff line number	Diff line change
`@@ -1540,7 +1540,7 @@ void PythonQtPrivate::setupSharedLibrarySuffixes()`
`1540`	`1540`	`_sharedLibrarySuffixes << "_d.so";`
`1541`	`1541`	`#endif`
`1542`	`1542`	`#endif`
`1543`		`- Q_FOREACH (QVariant entry, result.toList()) {`
	`1543`	`+ for( QVariant entry : result.toList( )) {`
`1544`	`1544`	`QVariantList suffixEntry = entry.toList();`
`1545`	`1545`	`if (suffixEntry.count()==3) {`
`1546`	`1546`	`int code = suffixEntry.at(2).toInt();`
`@@ -1609,7 +1609,7 @@ void PythonQtPrivate::addDecorators(QObject* o, int decoTypes)`
`1609`	`1609`
`1610`	`1610`	`void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)`
`1611`	`1611`	`{`
`1612`		`- Q_FOREACH(QString name, names) {`
	`1612`	`+ for( QString name : names ) {`
`1613`	`1613`	`_knownQObjectClassNames.insert(name.toUtf8(), true);`
`1614`	`1614`	`}`
`1615`	`1615`	`}`
`@@ -1624,7 +1624,7 @@ void PythonQt::removeSignalHandlers()`
`1624`	`1624`	`QList<PythonQtSignalReceiver*> signalReceivers = _p->_signalReceivers.values();`
`1625`	`1625`
`1626`	`1626`	`// just delete all signal receivers, they will remove themselves via removeSignalEmitter()`
`1627`		`- foreach(PythonQtSignalReceiver* receiver, signalReceivers) {`
	`1627`	`+ for(PythonQtSignalReceiver* receiver : signalReceivers) {`
`1628`	`1628`	`delete receiver;`
`1629`	`1629`	`}`
`1630`	`1630`	`// just to be sure, clear the receiver map as well`
`@@ -2162,7 +2162,7 @@ PyObject* PythonQt::helpCalled(PythonQtClassInfo* info)`
`2162`	`2162`
`2163`	`2163`	`void PythonQt::clearNotFoundCachedMembers()`
`2164`	`2164`	`{`
`2165`		`- Q_FOREACH(PythonQtClassInfo* info, _p->_knownClassInfos) {`
	`2165`	`+ for( PythonQtClassInfo* info : _p->_knownClassInfos ) {`
`2166`	`2166`	`info->clearNotFoundCachedMembers();`
`2167`	`2167`	`}`
`2168`	`2168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ PythonQtClassInfo::~PythonQtClassInfo()`
`86`	`86`	`if (_destructor) {`
`87`	`87`	`_destructor->deleteOverloadsAndThis();`
`88`	`88`	`}`
`89`		`- Q_FOREACH(PythonQtSlotInfo* info, _decoratorSlots) {`
	`89`	`+ for( PythonQtSlotInfo* info : _decoratorSlots ) {`
`90`	`90`	`info->deleteOverloadsAndThis();`
`91`	`91`	`}`
`92`	`92`	`}`
`@@ -178,7 +178,7 @@ bool PythonQtClassInfo::lookForPropertyAndCache(const char* memberName)`
`178`	`178`	`PythonQtSlotInfo* PythonQtClassInfo::recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset)`
`179`	`179`	`{`
`180`	`180`	`inputInfo = findDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset);`
`181`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`181`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`182`	`182`	`inputInfo = info._parent->recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset+info._upcastingOffset);`
`183`	`183`	`}`
`184`	`184`	`return inputInfo;`
`@@ -330,7 +330,7 @@ PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)`
`330`	`330`	`// look for dynamic decorators in this class and in derived classes`
`331`	`331`	`QList<QObject*> decoObjects;`
`332`	`332`	`recursiveCollectDecoratorObjects(decoObjects);`
`333`		`- Q_FOREACH(QObject* deco, decoObjects) {`
	`333`	`+ for( QObject* deco : decoObjects ) {`
`334`	`334`	`// call on ourself for caching, but with different metaObject():`
`335`	`335`	`found = lookForEnumAndCache(deco->metaObject(), memberName);`
`336`	`336`	`if (found) {`
`@@ -349,7 +349,7 @@ PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)`
`349`	`349`	`found = true;`
`350`	`350`	`}`
`351`	`351`	`// maybe it is a nested class?`
`352`		`- Q_FOREACH(PythonQtClassInfo* nestedClass, _nestedClasses) {`
	`352`	`+ for( PythonQtClassInfo* nestedClass : _nestedClasses ) {`
`353`	`353`	`PyObject* pyClass = nestedClass->pythonQtClassWrapper();`
`354`	`354`	`if (pyClass) {`
`355`	`355`	`if (strcmp(memberName, nestedClass->unscopedClassName().constData()) == 0) {`
`@@ -391,14 +391,14 @@ void PythonQtClassInfo::recursiveCollectDecoratorObjects(QList<QObject*>& decora`
`391`	`391`	`if (deco) {`
`392`	`392`	`decoratorObjects.append(deco);`
`393`	`393`	`}`
`394`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`394`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`395`	`395`	`info._parent->recursiveCollectDecoratorObjects(decoratorObjects);`
`396`	`396`	`}`
`397`	`397`	`}`
`398`	`398`
`399`	`399`	`void PythonQtClassInfo::recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects) {`
`400`	`400`	`classInfoObjects.append(this);`
`401`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`401`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`402`	`402`	`info._parent->recursiveCollectClassInfos(classInfoObjects);`
`403`	`403`	`}`
`404`	`404`	`}`
`@@ -493,7 +493,7 @@ QStringList PythonQtClassInfo::propertyList()`
`493`	`493`	`}`
`494`	`494`	`}`
`495`	`495`	`QStringList members = memberList();`
`496`		`- foreach(QString member, members) {`
	`496`	`+ for(const QString& member : members) {`
`497`	`497`	`if (member.startsWith("py_get_")) {`
`498`	`498`	`l << member.mid(7);`
`499`	`499`	`}`
`@@ -524,7 +524,7 @@ QStringList PythonQtClassInfo::memberList()`
`524`	`524`	`// look for dynamic decorators in this class and in derived classes`
`525`	`525`	`QList<PythonQtClassInfo*> infos;`
`526`	`526`	`recursiveCollectClassInfos(infos);`
`527`		`- Q_FOREACH(PythonQtClassInfo* info, infos) {`
	`527`	`+ for( PythonQtClassInfo* info : infos ) {`
`528`	`528`	`info->listDecoratorSlotsFromDecoratorProvider(l, false);`
`529`	`529`	`}`
`530`	`530`	`}`
`@@ -537,11 +537,11 @@ QStringList PythonQtClassInfo::memberList()`
`537`	`537`	`// check enums in the class hierachy of CPP classes`
`538`	`538`	`QList<QObject*> decoObjects;`
`539`	`539`	`recursiveCollectDecoratorObjects(decoObjects);`
`540`		`- Q_FOREACH(QObject* deco, decoObjects) {`
	`540`	`+ for( QObject* deco : decoObjects ) {`
`541`	`541`	`enumMetaObjects << deco->metaObject();`
`542`	`542`	`}`
`543`	`543`
`544`		`- Q_FOREACH(const QMetaObject* meta, enumMetaObjects) {`
	`544`	`+ for( const QMetaObject* meta : enumMetaObjects ) {`
`545`	`545`	`for (int i = 0; i<meta->enumeratorCount(); i++) {`
`546`	`546`	`QMetaEnum e = meta->enumerator(i);`
`547`	`547`	`l << e.name();`
`@@ -554,7 +554,7 @@ QStringList PythonQtClassInfo::memberList()`
`554`	`554`	`}`
`555`	`555`	`}`
`556`	`556`
`557`		`- Q_FOREACH(PythonQtClassInfo* nestedClass, _nestedClasses) {`
	`557`	`+ for( PythonQtClassInfo* nestedClass : _nestedClasses ) {`
`558`	`558`	`PyObject* pyClass = nestedClass->pythonQtClassWrapper();`
`559`	`559`	`if (pyClass) {`
`560`	`560`	`QByteArray name = nestedClass->unscopedClassName();`
`@@ -583,7 +583,7 @@ void* PythonQtClassInfo::castTo(void* ptr, const char* classname)`
`583`	`583`	`if (_wrappedClassName == classname) {`
`584`	`584`	`return ptr;`
`585`	`585`	`}`
`586`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`586`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`587`	`587`	`void* result = info._parent->castTo((char*)ptr + info._upcastingOffset, classname);`
`588`	`588`	`if (result) {`
`589`	`589`	`return result;`
`@@ -597,7 +597,7 @@ bool PythonQtClassInfo::inherits(const char* name)`
`597`	`597`	`if (_wrappedClassName == name) {`
`598`	`598`	`return true;`
`599`	`599`	`}`
`600`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`600`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`601`	`601`	`if (info._parent->inherits(name)) {`
`602`	`602`	`return true;`
`603`	`603`	`}`
`@@ -610,7 +610,7 @@ bool PythonQtClassInfo::inherits(PythonQtClassInfo* classInfo)`
`610`	`610`	`if (classInfo == this) {`
`611`	`611`	`return true;`
`612`	`612`	`}`
`613`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`613`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`614`	`614`	`if (info._parent->inherits(classInfo)) {`
`615`	`615`	`return true;`
`616`	`616`	`}`
`@@ -767,14 +767,14 @@ QObject* PythonQtClassInfo::decorator()`
`767`	`767`	`void* PythonQtClassInfo::recursiveCastDownIfPossible(void* ptr, const char** resultClassName)`
`768`	`768`	`{`
`769`	`769`	`if (!_polymorphicHandlers.isEmpty()) {`
`770`		`- Q_FOREACH(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {`
	`770`	`+ for( PythonQtPolymorphicHandlerCB* cb : _polymorphicHandlers ) {`
`771`	`771`	`void* resultPtr = (*cb)(ptr, resultClassName);`
`772`	`772`	`if (resultPtr) {`
`773`	`773`	`return resultPtr;`
`774`	`774`	`}`
`775`	`775`	`}`
`776`	`776`	`}`
`777`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`777`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`778`	`778`	`if (!info._parent->isQObject()) {`
`779`	`779`	`void* resultPtr = info._parent->recursiveCastDownIfPossible((char*)ptr + info._upcastingOffset, resultClassName);`
`780`	`780`	`if (resultPtr) {`
`@@ -818,7 +818,7 @@ void* PythonQtClassInfo::castDownIfPossible(void* ptr, PythonQtClassInfo** resul`
`818`	`818`	`// we only do downcasting on the base object, not on the whole inheritance tree...`
`819`	`819`	`void* resultPtr = nullptr;`
`820`	`820`	`if (!_polymorphicHandlers.isEmpty()) {`
`821`		`- Q_FOREACH(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {`
	`821`	`+ for( PythonQtPolymorphicHandlerCB* cb : _polymorphicHandlers ) {`
`822`	`822`	`resultPtr = (*cb)(ptr, &className);`
`823`	`823`	`if (resultPtr) {`
`824`	`824`	`break;`
`@@ -897,7 +897,7 @@ void PythonQtClassInfo::createEnumWrappers(const QObject* decoratorProvider)`
`897`	`897`	`if (decoratorProvider) {`
`898`	`898`	`createEnumWrappers(decoratorProvider->metaObject());`
`899`	`899`	`}`
`900`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`900`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`901`	`901`	`// trigger decorator() instead of createEnumWrappers(),`
`902`	`902`	`// which will then call createEnumWrappers().`
`903`	`903`	`info._parent->decorator();`
`@@ -912,13 +912,13 @@ PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {`
`912`	`912`	`// which will then call createEnumWrappers().`
`913`	`913`	`decorator();`
`914`	`914`	`}`
`915`		`- Q_FOREACH(const PythonQtObjectPtr& p, _enumWrappers) {`
	`915`	`+ for( const PythonQtObjectPtr& p : _enumWrappers ) {`
`916`	`916`	`const char* className = ((PyTypeObject*)p.object())->tp_name;`
`917`	`917`	`if (qstrcmp(className, name)==0) {`
`918`	`918`	`return p.object();`
`919`	`919`	`}`
`920`	`920`	`}`
`921`		`- Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
	`921`	`+ for( const ParentClassInfo& info : _parentClasses ) {`
`922`	`922`	`PyObject* p = info._parent->findEnumWrapper(name);`
`923`	`923`	`if (p) return p;`
`924`	`924`	`}`