Port code to use size() instead of count() of Qt containers

count() will be deprecated.

Fix some integer types in loops and modernize code
in changed lines.

Pick-to: 6.2
Change-Id: Idf21927661ea6c8866ee36e7c623043271e21620
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>

28 files changed, 160 insertions, 157 deletions

diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index de4d62bd9..56df06bb6 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -1629,7 +1629,7 @@ AbstractMetaFunction *
 
     const auto &args = addedFunc->arguments();
 
-    qsizetype argCount = args.count();
+    qsizetype argCount = args.size();
     // Check "foo(void)"
     if (argCount == 1 && args.constFirst().typeInfo.isVoid())
         argCount = 0;
@@ -2784,7 +2784,7 @@ std::optional<AbstractMetaType>
 
     if (returned.hasInstantiations()) {
         AbstractMetaTypeList instantiations = returned.instantiations();
-        for (int i = 0; i < instantiations.count(); ++i) {
+        for (qsizetype i = 0; i < instantiations.size(); ++i) {
             auto ins = inheritTemplateType(templateTypes, instantiations.at(i));
             if (!ins.has_value())
                 return {};
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
index 4be3afc4f..9a9297469 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
@@ -500,7 +500,7 @@ QString AbstractMetaFunctionPrivate::signature() const
 
         m_cachedSignature += QLatin1Char('(');
 
-        for (int i = 0; i < m_arguments.count(); ++i) {
+        for (qsizetype i = 0; i < m_arguments.size(); ++i) {
             const AbstractMetaArgument &a = m_arguments.at(i);
             const AbstractMetaType &t = a.type();
             if (i > 0)
@@ -911,7 +911,7 @@ QString AbstractMetaFunctionPrivate::formatMinimalSignature(const AbstractMetaFu
                                                             bool comment) const
 {
     QString result = m_originalName + QLatin1Char('(');
-    for (int i = 0; i < m_arguments.count(); ++i) {
+    for (qsizetype i = 0; i < m_arguments.size(); ++i) {
         if (i > 0)
             result += QLatin1Char(',');
 
diff --git a/sources/shiboken6/ApiExtractor/parser/codemodel.cpp b/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
index 4364f695c..c8978ba8d 100644
--- a/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
+++ b/sources/shiboken6/ApiExtractor/parser/codemodel.cpp
@@ -884,12 +884,12 @@ bool _FunctionModelItem::isSimilar(const FunctionModelItem &other) const
     if (isVariadics() != other->isVariadics())
         return false;
 
-    if (arguments().count() != other->arguments().count())
+    if (arguments().size() != other->arguments().size())
         return false;
 
     // ### check the template parameters
 
-    for (int i = 0; i < arguments().count(); ++i) {
+    for (qsizetype i = 0; i < arguments().size(); ++i) {
         ArgumentModelItem arg1 = arguments().at(i);
         ArgumentModelItem arg2 = other->arguments().at(i);
 
diff --git a/sources/shiboken6/ApiExtractor/parser/typeinfo.cpp b/sources/shiboken6/ApiExtractor/parser/typeinfo.cpp
index e3fdeac84..a6db82b35 100644
--- a/sources/shiboken6/ApiExtractor/parser/typeinfo.cpp
+++ b/sources/shiboken6/ApiExtractor/parser/typeinfo.cpp
@@ -426,7 +426,7 @@ QString TypeInfo::toString() const
 
     if (isFunctionPointer()) {
         tmp += QLatin1String(" (*)(");
-        for (int i = 0; i < d->m_arguments.count(); ++i) {
+        for (qsizetype i = 0; i < d->m_arguments.size(); ++i) {
             if (i != 0)
                 tmp += QLatin1String(", ");
 
@@ -446,11 +446,11 @@ QString TypeInfo::toString() const
 
 bool TypeInfoData::equals(const TypeInfoData &other) const
 {
-    if (m_arrayElements.count() != other.m_arrayElements.count())
+    if (m_arrayElements.size() != other.m_arrayElements.size())
         return false;
 
 #if defined (RXX_CHECK_ARRAY_ELEMENTS) // ### it'll break
-    for (int i = 0; i < arrayElements().count(); ++i) {
+    for (qsizetype i = 0; i < arrayElements().size(); ++i) {
         QString elt1 = arrayElements().at(i).trimmed();
         QString elt2 = other.arrayElements().at(i).trimmed();
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
index 850df753f..0a22f08af 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -42,7 +42,7 @@ void TestAbstractMetaClass::testClassName()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes.size(), 1);
     QCOMPARE(classes[0]->name(), QLatin1String("ClassName"));
 }
 
@@ -58,7 +58,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2); // 1 namespace + 1 class
+    QCOMPARE(classes.size(), 2); // 1 namespace + 1 class
     if (classes.constFirst()->name() != QLatin1String("ClassName"))
         qSwap(classes[0], classes[1]);
 
@@ -130,7 +130,7 @@ public:
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 4);
+    QCOMPARE(classes.size(), 4);
     AbstractMetaClass* a = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     AbstractMetaClass* b = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     AbstractMetaClass* c = AbstractMetaClass::findClass(classes, QLatin1String("C"));
@@ -240,10 +240,11 @@ void TestAbstractMetaClass::testDefaultValues()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
-    QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1);
-    const auto method = classA->queryFunctionsByName(QLatin1String("method")).constFirst();
+    const auto candidates = classA->queryFunctionsByName(u"method"_qs);
+    QCOMPARE(candidates.size(), 1);
+    const auto &method = candidates.constFirst();
     const AbstractMetaArgument &arg = method->arguments().constFirst();
     QCOMPARE(arg.defaultValueExpression(), arg.originalDefaultValueExpression());
 }
@@ -269,10 +270,10 @@ void TestAbstractMetaClass::testModifiedDefaultValues()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     const auto methodMatches = classA->queryFunctionsByName(QLatin1String("method"));
-    QCOMPARE(methodMatches.count(), 1);
+    QCOMPARE(methodMatches.size(), 1);
     const auto method = methodMatches.constFirst();
     const AbstractMetaArgument &arg = method->arguments().constFirst();
     QCOMPARE(arg.defaultValueExpression(), QLatin1String("Hello"));
@@ -295,7 +296,7 @@ void TestAbstractMetaClass::testInnerClassOfAPolymorphicOne()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     QVERIFY(classA->isPolymorphic());
@@ -323,7 +324,7 @@ void TestAbstractMetaClass::testForwardDeclaredInnerClass()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("A::B"));
@@ -354,7 +355,7 @@ void TestAbstractMetaClass::testSpecialFunctions()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
 
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
@@ -420,7 +421,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 6);
+    QCOMPARE(classes.size(), 6);
 
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
@@ -489,7 +490,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
@@ -527,7 +528,7 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes.size(), 1);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
@@ -548,7 +549,7 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes.size(), 1);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
 
@@ -584,7 +585,7 @@ void TestAbstractMetaClass::testIsPolymorphic()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     AbstractMetaClass* b = AbstractMetaClass::findClass(classes, QLatin1String("A"));
 
     QVERIFY(!b->isPolymorphic());
@@ -614,7 +615,7 @@ class Derived : public BaseAlias2 {
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     auto base = AbstractMetaClass::findClass(classes, QLatin1String("Base"));
     QVERIFY(base);
     auto derived = AbstractMetaClass::findClass(classes, QLatin1String("Derived"));
@@ -699,13 +700,13 @@ public:
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     auto base = AbstractMetaClass::findClass(classes, QLatin1String("Base"));
     QVERIFY(base);
     auto derived = AbstractMetaClass::findClass(classes, QLatin1String("Derived"));
     QVERIFY(derived);
     const auto usingMembers = derived->usingMembers();
-    QCOMPARE(usingMembers.count(), 2);
+    QCOMPARE(usingMembers.size(), 2);
     for (const auto &um : usingMembers) {
         QCOMPARE(um.access, Access::Public);
         QCOMPARE(um.baseClass, base);
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
index 897940cd5..a6123ef7e 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
@@ -205,10 +205,10 @@ void TestAbstractMetaType::testTypedefWithTemplates()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     const auto functions = builder->globalFunctions();
-    QCOMPARE(functions.count(), 1);
+    QCOMPARE(functions.size(), 1);
     const auto function = functions.constFirst();
     AbstractMetaArgumentList args = function->arguments();
-    QCOMPARE(args.count(), 1);
+    QCOMPARE(args.size(), 1);
     const AbstractMetaArgument &arg = args.constFirst();
     AbstractMetaType metaType = arg.type();
     QCOMPARE(metaType.cppSignature(), QLatin1String("A<B >"));
@@ -232,11 +232,11 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue()
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const auto overloads = classA->queryFunctionsByName(QLatin1String("method"));
-    QCOMPARE(overloads.count(), 1);
+    QCOMPARE(overloads.size(), 1);
     const auto method = overloads.constFirst();
     QVERIFY(method);
     AbstractMetaArgumentList args = method->arguments();
-    QCOMPARE(args.count(), 1);
+    QCOMPARE(args.size(), 1);
     const AbstractMetaArgument &arg = args.constFirst();
     AbstractMetaType metaType = arg.type();
     QCOMPARE(metaType.cppSignature(), QLatin1String("A"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
index 1c5e31f35..b2f09db76 100644
--- a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
@@ -44,7 +44,7 @@ void TestAddFunction::testParsingFuncNameAndConstness()
                                                  &errorMessage);
     QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
     QCOMPARE(f1->name(), QLatin1String("func"));
-    QCOMPARE(f1->arguments().count(), 3);
+    QCOMPARE(f1->arguments().size(), 3);
     TypeInfo retval = f1->returnType();
     QCOMPARE(retval.qualifiedName(), QStringList{QLatin1String("void")});
     QCOMPARE(retval.indirections(), 0);
@@ -59,7 +59,7 @@ void TestAddFunction::testParsingFuncNameAndConstness()
     QVERIFY2(!f2.isNull(), qPrintable(errorMessage));
     QCOMPARE(f2->name(), QLatin1String("_fu__nc_"));
     const auto &args = f2->arguments();
-    QCOMPARE(args.count(), 4);
+    QCOMPARE(args.size(), 4);
     retval = f2->returnType();
     QCOMPARE(retval.qualifiedName(), QStringList{QLatin1String("Abc")});
     QCOMPARE(retval.instantiations().size(), 2);
@@ -87,7 +87,7 @@ void TestAddFunction::testParsingFuncNameAndConstness()
                                                  &errorMessage);
     QVERIFY2(!f3.isNull(), qPrintable(errorMessage));
     QCOMPARE(f3->name(), QLatin1String("func"));
-    QCOMPARE(f3->arguments().count(), 0);
+    QCOMPARE(f3->arguments().size(), 0);
 
     // const call operator
     const char sig4[] = "operator()(int)const";
@@ -95,7 +95,7 @@ void TestAddFunction::testParsingFuncNameAndConstness()
                                                  &errorMessage);
     QVERIFY2(!f4.isNull(), qPrintable(errorMessage));
     QCOMPARE(f4->name(), QLatin1String("operator()"));
-    QCOMPARE(f4->arguments().count(), 1);
+    QCOMPARE(f4->arguments().size(), 1);
     QVERIFY(f4->isConstant());
 }
 
@@ -123,7 +123,8 @@ struct A {
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->functions().count(), 5); // default ctor, default copy ctor, func a() and the added functions
+    // default ctor, default copy ctor, func a() and the added functions
+    QCOMPARE(classA->functions().size(), 5);
 
     auto addedFunc = classA->findFunction(QLatin1String("b"));
     QVERIFY(addedFunc);
@@ -141,7 +142,7 @@ struct A {
     AbstractMetaType returnType = addedFunc->type();
     QCOMPARE(returnType.typeEntry(), typeDb->findPrimitiveType(QLatin1String("int")));
     const AbstractMetaArgumentList &args = addedFunc->arguments();
-    QCOMPARE(args.count(), 3);
+    QCOMPARE(args.size(), 3);
     QCOMPARE(args.at(0).type().typeEntry(), returnType.typeEntry());
     QCOMPARE(args.at(1).defaultValueExpression(), QLatin1String("4.6"));
     QCOMPARE(args.at(2).type().typeEntry(), typeDb->findType(QLatin1String("B")));
@@ -165,7 +166,7 @@ void TestAddFunction::testAddFunctionConstructor()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->functions().count(), 3); // default and added ctors
+    QCOMPARE(classA->functions().size(), 3); // default and added ctors
     const auto addedFunc = classA->functions().constLast();
     QCOMPARE(addedFunc->access(), Access::Public);
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::ConstructorFunction);
@@ -188,7 +189,8 @@ void TestAddFunction::testAddFunctionTagDefaultValues()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->functions().count(), 3); // default ctor, default copy ctor and the added function
+    // default ctor, default copy ctor and the added function
+    QCOMPARE(classA->functions().size(), 3);
     const auto addedFunc = classA->functions().constLast();
     QCOMPARE(addedFunc->access(), Access::Public);
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
@@ -225,7 +227,7 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
                                                  &errorMessage);
     QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
     QCOMPARE(f1->name(), QLatin1String("func"));
-    QCOMPARE(f1->arguments().count(), 0);
+    QCOMPARE(f1->arguments().size(), 0);
     QCOMPARE(f1->isConstant(), false);
 
     const char cppCode[] = "struct A {};\n";
@@ -246,7 +248,9 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
     const auto addedFunc = classA->findFunction(QLatin1String("func"));
     QVERIFY(!addedFunc.isNull());
     QVERIFY(addedFunc->hasInjectedCode());
-    QCOMPARE(addedFunc->injectedCodeSnips(TypeSystem::CodeSnipPositionAny, TypeSystem::TargetLangCode).count(), 1);
+    const auto snips = addedFunc->injectedCodeSnips(TypeSystem::CodeSnipPositionAny,
+                                                    TypeSystem::TargetLangCode);
+    QCOMPARE(snips.size(), 1);
 }
 
 void TestAddFunction::testAddFunctionWithDefaultArgs()
@@ -257,7 +261,7 @@ void TestAddFunction::testAddFunctionWithDefaultArgs()
                                                  &errorMessage);
     QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
     QCOMPARE(f1->name(), QLatin1String("func"));
-    QCOMPARE(f1->arguments().count(), 0);
+    QCOMPARE(f1->arguments().size(), 0);
     QCOMPARE(f1->isConstant(), false);
 
     const char cppCode[] = "struct A { };\n";
@@ -324,7 +328,7 @@ void TestAddFunction::testAddFunctionWithVarargs()
                                                  &errorMessage);
     QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
     QCOMPARE(f1->name(), QLatin1String("func"));
-    QCOMPARE(f1->arguments().count(), 3);
+    QCOMPARE(f1->arguments().size(), 3);
     QVERIFY(!f1->isConstant());
 
     const char cppCode[] = "struct A {};\n";
@@ -389,7 +393,7 @@ void TestAddFunction::testAddGlobalFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     const auto globalFuncs = builder->globalFunctions();
-    QCOMPARE(globalFuncs.count(), 2);
+    QCOMPARE(globalFuncs.size(), 2);
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(builder->classes(), QLatin1String("B"));
     QVERIFY(classB);
     QVERIFY(!classB->findFunction(QLatin1String("globalFunc")));
@@ -415,7 +419,7 @@ void TestAddFunction::testAddFunctionWithApiVersion()
                                                                 true, QLatin1String("0.1")));
     QVERIFY(!builder.isNull());
     const auto globalFuncs = builder->globalFunctions();
-    QCOMPARE(globalFuncs.count(), 1);
+    QCOMPARE(globalFuncs.size(), 1);
 }
 
 void TestAddFunction::testModifyAddedFunction()
@@ -493,7 +497,7 @@ void TestAddFunction::testAddFunctionWithTemplateArg()
     QCOMPARE(builder->globalFunctions().size(), 1);
     const auto func = builder->globalFunctions().constFirst();
     const AbstractMetaArgument &arg = func->arguments().constFirst();
-    QCOMPARE(arg.type().instantiations().count(), 1);
+    QCOMPARE(arg.type().instantiations().size(), 1);
 }
 
 // Test splitting of <add-function> parameter lists.
diff --git a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
index 42a3fe08b..6173a968b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
@@ -80,7 +80,7 @@ void TestCodeInjections::testReadFile()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
-    QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
+    QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
     QString code = classA->typeEntry()->codeSnips().constFirst().code();
     QVERIFY(code.indexOf(expected) != -1);
     code = classA->typeEntry()->targetConversionRule();
@@ -104,7 +104,7 @@ void TestCodeInjections::testInjectWithValidApiVersion()
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
-    QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
+    QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
 }
 
 void TestCodeInjections::testInjectWithInvalidApiVersion()
@@ -125,7 +125,7 @@ void TestCodeInjections::testInjectWithInvalidApiVersion()
 
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
-    QCOMPARE(classA->typeEntry()->codeSnips().count(), 0);
+    QCOMPARE(classA->typeEntry()->codeSnips().size(), 0);
 }
 
 void TestCodeInjections::testTextStream()
diff --git a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
index 3ee39e4ec..82f37f393 100644
--- a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
@@ -54,7 +54,7 @@ void TestContainer::testContainerType()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     //search for class A
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
@@ -87,11 +87,11 @@ void TestContainer::testListOfValueType()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 3);
+    QCOMPARE(classes.size(), 3);
 
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->templateBaseClassInstantiations().count(), 1);
+    QCOMPARE(classA->templateBaseClassInstantiations().size(), 1);
     const AbstractMetaType templateInstanceType =
         classA->templateBaseClassInstantiations().constFirst();
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
index 32071f533..8d10f17cc 100644
--- a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
@@ -60,10 +60,10 @@ void TestConversionOperator::testConversionOperator()
     QVERIFY(classA);
     QVERIFY(classB);
     QVERIFY(classC);
-    QCOMPARE(classA->functions().count(), 2);
-    QCOMPARE(classB->functions().count(), 3);
-    QCOMPARE(classC->functions().count(), 3);
-    QCOMPARE(classA->externalConversionOperators().count(), 2);
+    QCOMPARE(classA->functions().size(), 2);
+    QCOMPARE(classB->functions().size(), 3);
+    QCOMPARE(classC->functions().size(), 3);
+    QCOMPARE(classA->externalConversionOperators().size(), 2);
 
     AbstractMetaFunctionCPtr convOp;
     for (const auto &func : classB->functions()) {
@@ -94,7 +94,7 @@ void TestConversionOperator::testConversionOperatorOfDiscardedClass()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->externalConversionOperators().count(), 0);
+    QCOMPARE(classA->externalConversionOperators().size(), 0);
 }
 
 void TestConversionOperator::testRemovedConversionOperator()
@@ -120,10 +120,10 @@ void TestConversionOperator::testRemovedConversionOperator()
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classA);
     QVERIFY(classB);
-    QCOMPARE(classA->functions().count(), 2);
-    QCOMPARE(classB->functions().count(), 3);
-    QCOMPARE(classA->externalConversionOperators().count(), 0);
-    QCOMPARE(classA->implicitConversions().count(), 0);
+    QCOMPARE(classA->functions().size(), 2);
+    QCOMPARE(classB->functions().size(), 3);
+    QCOMPARE(classA->externalConversionOperators().size(), 0);
+    QCOMPARE(classA->implicitConversions().size(), 0);
 }
 
 void TestConversionOperator::testConversionOperatorReturningReference()
@@ -146,14 +146,14 @@ void TestConversionOperator::testConversionOperatorReturningReference()
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classA);
     QVERIFY(classB);
-    QCOMPARE(classA->functions().count(), 2);
-    QCOMPARE(classB->functions().count(), 3);
-    QCOMPARE(classA->externalConversionOperators().count(), 1);
+    QCOMPARE(classA->functions().size(), 2);
+    QCOMPARE(classB->functions().size(), 3);
+    QCOMPARE(classA->externalConversionOperators().size(), 1);
     QCOMPARE(classA->externalConversionOperators().constFirst()->type().cppSignature(),
              QLatin1String("A"));
     QCOMPARE(classA->externalConversionOperators().constFirst()->ownerClass()->name(),
              QLatin1String("B"));
-    QCOMPARE(classA->implicitConversions().count(), 1);
+    QCOMPARE(classA->implicitConversions().size(), 1);
     QCOMPARE(classA->implicitConversions().constFirst()->type().cppSignature(),
              QLatin1String("A"));
     QCOMPARE(classA->implicitConversions().constFirst()->ownerClass()->name(),
@@ -180,14 +180,14 @@ void TestConversionOperator::testConversionOperatorReturningConstReference()
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classA);
     QVERIFY(classB);
-    QCOMPARE(classA->functions().count(), 2);
-    QCOMPARE(classB->functions().count(), 3);
-    QCOMPARE(classA->externalConversionOperators().count(), 1);
+    QCOMPARE(classA->functions().size(), 2);
+    QCOMPARE(classB->functions().size(), 3);
+    QCOMPARE(classA->externalConversionOperators().size(), 1);
     QCOMPARE(classA->externalConversionOperators().constFirst()->type().cppSignature(),
              QLatin1String("A"));
     QCOMPARE(classA->externalConversionOperators().constFirst()->ownerClass()->name(),
              QLatin1String("B"));
-    QCOMPARE(classA->implicitConversions().count(), 1);
+    QCOMPARE(classA->implicitConversions().size(), 1);
     QCOMPARE(classA->implicitConversions().constFirst()->type().cppSignature(),
              QLatin1String("A"));
     QCOMPARE(classA->implicitConversions().constFirst()->ownerClass()->name(),
diff --git a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
index 7718d3df6..6e6cfb267 100644
--- a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
@@ -46,7 +46,7 @@ void TestCtorInformation::testCtorIsPrivate()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 3);
+    QCOMPARE(classes.size(), 3);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->hasNonPrivateConstructor(), true);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->hasNonPrivateConstructor(), false);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("CtorLess"))->hasNonPrivateConstructor(), true);
@@ -66,7 +66,7 @@ void TestCtorInformation::testHasNonPrivateCtor()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     const AbstractMetaClass *base = AbstractMetaClass::findClass(classes, QLatin1String("Base"));
     QCOMPARE(base->hasNonPrivateConstructor(), true);
     const AbstractMetaClass *derived = AbstractMetaClass::findClass(classes, QLatin1String("Derived"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
index 303532b65..8f66c9ef6 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
@@ -88,7 +88,7 @@ void TestDropTypeEntries::testDropEntries()
     QVERIFY(!AbstractMetaClass::findClass(classes, QLatin1String("NamespaceB")));
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
-    QCOMPARE(globalEnums.count(), 1);
+    QCOMPARE(globalEnums.size(), 1);
     QCOMPARE(globalEnums.constFirst().name(), QLatin1String("EnumA"));
 
     TypeDatabase* td = TypeDatabase::instance();
diff --git a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
index 0eee8af24..de3acd6c7 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
@@ -40,7 +40,7 @@ void TestDtorInformation::testDtorIsPrivate()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->hasPrivateDestructor(), false);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->hasPrivateDestructor(), true);
 }
@@ -52,7 +52,7 @@ void TestDtorInformation::testDtorIsProtected()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->hasProtectedDestructor(), false);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->hasProtectedDestructor(), true);
 }
@@ -64,7 +64,7 @@ void TestDtorInformation::testDtorIsVirtual()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->hasVirtualDestructor(), false);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->hasVirtualDestructor(), true);
 }
@@ -85,7 +85,7 @@ class Subject : public SubjectBase {};
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 4);
+    QCOMPARE(classes.size(), 4);
 
     auto klass = AbstractMetaClass::findClass(classes, QLatin1String("ControlBase"));
     QVERIFY(klass);
@@ -109,7 +109,7 @@ void TestDtorInformation::testClassWithVirtualDtorIsPolymorphic()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Control"))->isPolymorphic(), true);
     QCOMPARE(AbstractMetaClass::findClass(classes, QLatin1String("Subject"))->isPolymorphic(), true);
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
index c1d552786..216233e73 100644
--- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
@@ -58,29 +58,29 @@ void TestEnum::testEnumCppSignature()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes.size(), 1);
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
-    QCOMPARE(globalEnums.count(), 1);
+    QCOMPARE(globalEnums.size(), 1);
     QCOMPARE(globalEnums.constFirst().name(), QLatin1String("GlobalEnum"));
 
     // enum as parameter of a function
     const auto functions = builder->globalFunctions();
-    QCOMPARE(functions.count(), 1);
-    QCOMPARE(functions.constFirst()->arguments().count(), 1);
+    QCOMPARE(functions.size(), 1);
+    QCOMPARE(functions.constFirst()->arguments().size(), 1);
     QCOMPARE(functions.constFirst()->arguments().constFirst().type().cppSignature(),
              QLatin1String("A::ClassEnum"));
 
     // enum as parameter of a method
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
-    QCOMPARE(classA->enums().count(), 1);
+    QCOMPARE(classA->enums().size(), 1);
     const auto funcs = classA->queryFunctionsByName(QLatin1String("method"));
     QVERIFY(!funcs.isEmpty());
     const auto method = funcs.constFirst();
     AbstractMetaArgument arg = method->arguments().constFirst();
     QCOMPARE(arg.type().name(), QLatin1String("ClassEnum"));
     QCOMPARE(arg.type().cppSignature(), QLatin1String("A::ClassEnum"));
-    QCOMPARE(functions.constFirst()->arguments().count(), 1);
+    QCOMPARE(functions.constFirst()->arguments().size(), 1);
     arg = functions.constFirst()->arguments().constFirst();
     QCOMPARE(arg.type().name(), QLatin1String("ClassEnum"));
     QCOMPARE(arg.type().cppSignature(), QLatin1String("A::ClassEnum"));
@@ -113,8 +113,8 @@ void TestEnum::testEnumWithApiVersion()
                                                                 true, QLatin1String("0.1")));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
-    QCOMPARE(classes[0]->enums().count(), 1);
+    QCOMPARE(classes.size(), 1);
+    QCOMPARE(classes[0]->enums().size(), 1);
 }
 
 void TestEnum::testAnonymousEnum()
@@ -140,14 +140,14 @@ void TestEnum::testAnonymousEnum()
     QVERIFY(!builder.isNull());
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
-    QCOMPARE(globalEnums.count(), 1);
+    QCOMPARE(globalEnums.size(), 1);
     QCOMPARE(globalEnums.constFirst().typeEntry()->qualifiedCppName(),
              QLatin1String("Global0"));
     QVERIFY(globalEnums.constFirst().isAnonymous());
 
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
-    QCOMPARE(classes[0]->enums().count(), 2);
+    QCOMPARE(classes.size(), 1);
+    QCOMPARE(classes[0]->enums().size(), 2);
 
     auto anonEnumA1 = classes[0]->findEnum(QLatin1String("A1"));
     QVERIFY(anonEnumA1.has_value());
@@ -195,7 +195,7 @@ void TestEnum::testGlobalEnums()
     QVERIFY(!builder.isNull());
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
-    QCOMPARE(globalEnums.count(), 2);
+    QCOMPARE(globalEnums.size(), 2);
 
     AbstractMetaEnum enumA = globalEnums.constFirst();
     QCOMPARE(enumA.typeEntry()->qualifiedCppName(), QLatin1String("EnumA"));
@@ -243,8 +243,8 @@ void TestEnum::testEnumValueFromNeighbourEnum()
     QVERIFY(!builder.isNull());
 
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
-    QCOMPARE(classes[0]->enums().count(), 2);
+    QCOMPARE(classes.size(), 1);
+    QCOMPARE(classes[0]->enums().size(), 2);
 
     auto enumA = classes[0]->findEnum(QLatin1String("EnumA"));
     QVERIFY(enumA.has_value());
@@ -384,7 +384,7 @@ void TestEnum::testPrivateEnum()
 
     AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->enums().count(), 2);
+    QCOMPARE(classA->enums().size(), 2);
 
     auto privateEnum = classA->findEnum(QLatin1String("PrivateEnum"));
     QVERIFY(privateEnum.has_value());
@@ -422,7 +422,7 @@ void TestEnum::testTypedefEnum()
     QVERIFY(!builder.isNull());
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
-    QCOMPARE(globalEnums.count(), 1);
+    QCOMPARE(globalEnums.size(), 1);
 
     AbstractMetaEnum enumA = globalEnums.constFirst();
     QCOMPARE(enumA.typeEntry()->qualifiedCppName(), QLatin1String("EnumA"));
@@ -484,7 +484,7 @@ namespace Test2
         return -1;
 
     const auto globalEnums = fixture->builder->globalEnums();
-    if (globalEnums.count() != 1)
+    if (globalEnums.size() != 1)
         return -2;
 
     fixture->globalEnum = AbstractMetaType(globalEnums.constFirst().typeEntry());
@@ -501,7 +501,7 @@ namespace Test2
         return -3;
 
     const auto namespaceEnums = testNamespace->enums();
-    if (namespaceEnums.count() != 2)
+    if (namespaceEnums.size() != 2)
         return -4;
     QList<const EnumTypeEntry *> enumTypeEntries{
         static_cast<const EnumTypeEntry *>(namespaceEnums.at(0).typeEntry()),
diff --git a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
index 90a6cd312..9f0afe2d9 100644
--- a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
@@ -51,7 +51,7 @@ void TestExtraInclude::testClassExtraInclude()
     QVERIFY(classA);
 
     QList<Include> includes = classA->typeEntry()->extraIncludes();
-    QCOMPARE(includes.count(), 1);
+    QCOMPARE(includes.size(), 1);
     QCOMPARE(includes.constFirst().name(), QLatin1String("header.h"));
 }
 
@@ -78,7 +78,7 @@ void TestExtraInclude::testGlobalExtraIncludes()
     QCOMPARE(module->name(), QLatin1String("Foo"));
 
     QList<Include> includes = module->extraIncludes();
-    QCOMPARE(includes.count(), 2);
+    QCOMPARE(includes.size(), 2);
     QCOMPARE(includes.constFirst().name(), QLatin1String("header1.h"));
     QCOMPARE(includes.constLast().name(), QLatin1String("header2.h"));
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
index 9dcdec975..e34a1b35a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
@@ -54,12 +54,12 @@ void TestImplicitConversions::testWithPrivateCtors()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 3);
+    QCOMPARE(classes.size(), 3);
 
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     const auto implicitConvs = classA->implicitConversions();
-    QCOMPARE(implicitConvs.count(), 1);
+    QCOMPARE(implicitConvs.size(), 1);
     QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(),
              classC->typeEntry());
 }
@@ -84,11 +84,11 @@ void TestImplicitConversions::testWithModifiedVisibility()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     const auto implicitConvs = classA->implicitConversions();
-    QCOMPARE(implicitConvs.count(), 1);
+    QCOMPARE(implicitConvs.size(), 1);
     QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(),
              classB->typeEntry());
 }
@@ -118,16 +118,16 @@ void TestImplicitConversions::testWithAddedCtor()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 3);
+    QCOMPARE(classes.size(), 3);
 
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     auto implicitConvs = classA->implicitConversions();
-    QCOMPARE(implicitConvs.count(), 2);
+    QCOMPARE(implicitConvs.size(), 2);
 
     // Added constructors with custom types should never result in implicit converters.
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     implicitConvs = classB->implicitConversions();
-    QCOMPARE(implicitConvs.count(), 0);
+    QCOMPARE(implicitConvs.size(), 0);
 }
 
 void TestImplicitConversions::testWithExternalConversionOperator()
@@ -145,13 +145,13 @@ void TestImplicitConversions::testWithExternalConversionOperator()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     const auto implicitConvs = classA->implicitConversions();
-    QCOMPARE(implicitConvs.count(), 1);
+    QCOMPARE(implicitConvs.size(), 1);
     const auto &externalConvOps = classA->externalConversionOperators();
-    QCOMPARE(externalConvOps.count(), 1);
+    QCOMPARE(externalConvOps.size(), 1);
 
     AbstractMetaFunctionCPtr convOp;
     for (const auto &func : classB->functions()) {
diff --git a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
index fda6614f0..5c58b122f 100644
--- a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
@@ -50,10 +50,10 @@ void TestInsertTemplate::testInsertTemplateOnClassInjectCode()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes.size(), 1);
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
+    QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
     QString code = classA->typeEntry()->codeSnips().constFirst().code();
     QVERIFY(code.contains(QLatin1String("code template content")));
 }
@@ -79,7 +79,7 @@ void TestInsertTemplate::testInsertTemplateOnModuleInjectCode()
     QVERIFY(module);
     QCOMPARE(module->name(), QLatin1String("Foo"));
     QVERIFY(module);
-    QCOMPARE(module->codeSnips().count(), 1);
+    QCOMPARE(module->codeSnips().size(), 1);
     QString code = module->codeSnips().constFirst().code().trimmed();
     QVERIFY(code.contains(QLatin1String("code template content")));
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
index 521f8d665..f8c36b72b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
@@ -57,7 +57,7 @@ R"(<typesystem package="Foo">
     AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
     QVERIFY(classA);
     DocModificationList docMods = classA->typeEntry()->docModifications();
-    QCOMPARE(docMods.count(), 2);
+    QCOMPARE(docMods.size(), 2);
     QCOMPARE(docMods[0].code().trimmed(), QLatin1String("<brief>Modified Brief</brief>"));
     QCOMPARE(docMods[0].signature(), QString());
     QCOMPARE(docMods[1].code().trimmed(), QLatin1String("<para>Some changed contents here</para>"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
index 0d95d5abb..a96150453 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
@@ -308,15 +308,15 @@ void TestModifyFunction::testGlobalFunctionModification()
     QCOMPARE(builder->globalFunctions().size(), 1);
 
     FunctionModificationList mods = TypeDatabase::instance()->functionModifications(QLatin1String("function(A*)"));
-    QCOMPARE(mods.count(), 1);
+    QCOMPARE(mods.size(), 1);
     const QList<ArgumentModification> &argMods = mods.constFirst().argument_mods();
-    QCOMPARE(argMods.count(), 1);
+    QCOMPARE(argMods.size(), 1);
     ArgumentModification argMod = argMods.constFirst();
     QCOMPARE(argMod.replacedDefaultExpression(), QLatin1String("A()"));
 
     QVERIFY(!builder->globalFunctions().isEmpty());
     const auto func = builder->globalFunctions().constFirst();
-    QCOMPARE(func->arguments().count(), 1);
+    QCOMPARE(func->arguments().size(), 1);
     const AbstractMetaArgument &arg = func->arguments().constFirst();
     QCOMPARE(arg.type().cppSignature(), QLatin1String("A *"));
     QCOMPARE(arg.originalDefaultValueExpression(), QLatin1String("0"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
index 748adfc39..1b99ac43d 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
@@ -58,7 +58,7 @@ void TestMultipleInheritance::testVirtualClass()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 4);
+    QCOMPARE(classes.size(), 4);
 
     const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("D"));
     bool functionFound = false;
diff --git a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
index d536c0538..2f3198589 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
@@ -68,8 +68,8 @@ void TestNestedTypes::testNestedTypesModifications()
 
     const AbstractMetaClass *ins = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace"));
     QVERIFY(ins);
-    QCOMPARE(ins->functions().count(), 1);
-    QCOMPARE(ins->typeEntry()->codeSnips().count(), 1);
+    QCOMPARE(ins->functions().size(), 1);
+    QCOMPARE(ins->typeEntry()->codeSnips().size(), 1);
     CodeSnip snip = ins->typeEntry()->codeSnips().constFirst();
     QCOMPARE(snip.code().trimmed(), QLatin1String("custom_code1();"));
 
@@ -87,7 +87,7 @@ void TestNestedTypes::testNestedTypesModifications()
 
     const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace::SomeClass"));
     QVERIFY(ins);
-    QCOMPARE(sc->functions().count(), 2); // default constructor and removed method
+    QCOMPARE(sc->functions().size(), 2); // default constructor and removed method
     const auto removedFunc = sc->functions().constLast();
     QVERIFY(removedFunc->isModifiedRemoved());
 }
@@ -111,7 +111,7 @@ void TestNestedTypes::testDuplicationOfNestedTypes()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 2);
+    QCOMPARE(classes.size(), 2);
     const AbstractMetaClass *nspace = AbstractMetaClass::findClass(classes, QLatin1String("Namespace"));
     QVERIFY(nspace);
     const AbstractMetaClass *cls1 = AbstractMetaClass::findClass(classes, QLatin1String("SomeClass"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
index e78f9f274..e68553ee9 100644
--- a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
@@ -46,7 +46,7 @@ void TestPrimitiveTypeTag::testPrimitiveTypeDefaultConstructor()
     QVERIFY(!builder.isNull());
 
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes.size(), 1);
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
index 41103c24e..6b59bb236 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
@@ -55,7 +55,7 @@ void TestRemoveImplConv::testRemoveImplConv()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 3);
+    QCOMPARE(classes.size(), 3);
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
@@ -63,7 +63,7 @@ void TestRemoveImplConv::testRemoveImplConv()
     const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
     QVERIFY(classC);
     const auto implConv = classC->implicitConversions();
-    QCOMPARE(implConv.count(), 1);
+    QCOMPARE(implConv.size(), 1);
     QCOMPARE(implConv.constFirst()->arguments().constFirst().type().typeEntry(),
              classB->typeEntry());
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
index 3ad77c86f..cb7105d1d 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
@@ -50,7 +50,7 @@ void TestReverseOperators::testReverseSum()
     AbstractMetaClassList classes = builder->classes();
     AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->functions().count(), 4);
+    QCOMPARE(classA->functions().size(), 4);
 
     AbstractMetaFunctionCPtr reverseOp;
     AbstractMetaFunctionCPtr normalOp;
@@ -65,10 +65,10 @@ void TestReverseOperators::testReverseSum()
 
     QVERIFY(!normalOp.isNull());
     QVERIFY(!normalOp->isReverseOperator());
-    QCOMPARE(normalOp->arguments().count(), 1);
+    QCOMPARE(normalOp->arguments().size(), 1);
     QVERIFY(!reverseOp.isNull());
     QVERIFY(reverseOp->isReverseOperator());
-    QCOMPARE(reverseOp->arguments().count(), 1);
+    QCOMPARE(reverseOp->arguments().size(), 1);
 }
 
 void TestReverseOperators::testReverseSumWithAmbiguity()
@@ -92,11 +92,11 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
     AbstractMetaClassList classes = builder->classes();
     const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     QVERIFY(classA);
-    QCOMPARE(classA->functions().count(), 4);
+    QCOMPARE(classA->functions().size(), 4);
 
     const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     QVERIFY(classB);
-    QCOMPARE(classB->functions().count(), 4);
+    QCOMPARE(classB->functions().size(), 4);
 
     AbstractMetaFunctionCPtr reverseOp;
     AbstractMetaFunctionCPtr normalOp;
@@ -110,11 +110,11 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
     }
     QVERIFY(!normalOp.isNull());
     QVERIFY(!normalOp->isReverseOperator());
-    QCOMPARE(normalOp->arguments().count(), 1);
+    QCOMPARE(normalOp->arguments().size(), 1);
     QCOMPARE(normalOp->minimalSignature(), QLatin1String("operator+(B,A)"));
     QVERIFY(!reverseOp.isNull());
     QVERIFY(reverseOp->isReverseOperator());
-    QCOMPARE(reverseOp->arguments().count(), 1);
+    QCOMPARE(reverseOp->arguments().size(), 1);
     QCOMPARE(reverseOp->minimalSignature(), QLatin1String("operator+(A,B)"));
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
index 53cefaa49..083de6d6d 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
@@ -120,15 +120,15 @@ namespace Namespace {
     const auto func = classB->findFunction(QLatin1String("foo"));
     QVERIFY(!func.isNull());
     AbstractMetaType argType = func->arguments().constFirst().type();
-    QCOMPARE(argType.instantiations().count(), 1);
+    QCOMPARE(argType.instantiations().size(), 1);
     QCOMPARE(argType.typeEntry()->qualifiedCppName(), QLatin1String("QList"));
 
     const AbstractMetaType &instance1 = argType.instantiations().constFirst();
-    QCOMPARE(instance1.instantiations().count(), 1);
+    QCOMPARE(instance1.instantiations().size(), 1);
     QCOMPARE(instance1.typeEntry()->qualifiedCppName(), QLatin1String("Namespace::A"));
 
     const AbstractMetaType &instance2 = instance1.instantiations().constFirst();
-    QCOMPARE(instance2.instantiations().count(), 0);
+    QCOMPARE(instance2.instantiations().size(), 0);
     QCOMPARE(instance2.typeEntry()->qualifiedCppName(), QLatin1String("Namespace::E1"));
 }
 
@@ -149,7 +149,7 @@ void func(List<int> arg) {}
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     const auto globalFuncs = builder->globalFunctions();
-    QCOMPARE(globalFuncs.count(), 1);
+    QCOMPARE(globalFuncs.size(), 1);
 
     const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>)"));
@@ -174,7 +174,7 @@ void func(List<int>* arg) {}
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaFunctionCList globalFuncs = builder->globalFunctions();
-    QCOMPARE(globalFuncs.count(), 1);
+    QCOMPARE(globalFuncs.size(), 1);
 
     const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>*)"));
@@ -199,7 +199,7 @@ void func(List<int>& arg) {}
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     const auto globalFuncs = builder->globalFunctions();
-    QCOMPARE(globalFuncs.count(), 1);
+    QCOMPARE(globalFuncs.size(), 1);
 
     const auto func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>&)"));
@@ -229,7 +229,7 @@ struct List {
     QVERIFY(!builder.isNull());
     const AbstractMetaClassList templates = builder->templates();
 
-    QCOMPARE(templates.count(), 1);
+    QCOMPARE(templates.size(), 1);
     const AbstractMetaClass *list = templates.constFirst();
     // Verify that the parameter of "void append(List l)" gets fixed to "List<T >"
     const auto append = list->findFunction(QStringLiteral("append"));
@@ -270,14 +270,14 @@ struct FooBars : public ListContainer<FooBar> {};
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
     AbstractMetaClassList templates = builder->templates();
-    QCOMPARE(classes.count(), 2);
-    QCOMPARE(templates.count(), 1);
+    QCOMPARE(classes.size(), 2);
+    QCOMPARE(templates.size(), 1);
 
     const AbstractMetaClass* foobars = AbstractMetaClass::findClass(classes, QLatin1String("FooBars"));
-    QCOMPARE(foobars->functions().count(), 4);
+    QCOMPARE(foobars->functions().size(), 4);
 
     const AbstractMetaClass *lc = templates.constFirst();
-    QCOMPARE(lc->functions().count(), 2);
+    QCOMPARE(lc->functions().size(), 2);
 }
 
 void TestTemplates::testTemplateInheritanceMixedWithForwardDeclaration()
@@ -312,7 +312,7 @@ template<SomeEnum type> struct Future {};
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
     // 3 functions: simple constructor, copy constructor and "method()".
-    QCOMPARE(classB->functions().count(), 3);
+    QCOMPARE(classB->functions().size(), 3);
 }
 
 void TestTemplates::testTemplateInheritanceMixedWithNamespaceAndForwardDeclaration()
@@ -351,7 +351,7 @@ template<SomeEnum type> struct Future {};
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
     // 3 functions: simple constructor, copy constructor and "method()".
-    QCOMPARE(classB->functions().count(), 3);
+    QCOMPARE(classB->functions().size(), 3);
 }
 
 void TestTemplates::testTypedefOfInstantiationOfTemplateClass()
@@ -381,14 +381,14 @@ typedef BaseTemplateClass<TypeOne> TypeOneClass;
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 3);
+    QCOMPARE(classes.size(), 3);
 
     const AbstractMetaClass* base = AbstractMetaClass::findClass(classes, QLatin1String("BaseTemplateClass"));
     QVERIFY(base);
     const AbstractMetaClass* one = AbstractMetaClass::findClass(classes, QLatin1String("TypeOneClass"));
     QVERIFY(one);
     QCOMPARE(one->templateBaseClass(), base);
-    QCOMPARE(one->functions().count(), base->functions().count());
+    QCOMPARE(one->functions().size(), base->functions().size());
     QVERIFY(one->isTypeDef());
     const ComplexTypeEntry* oneType = one->typeEntry();
     const ComplexTypeEntry* baseType = base->typeEntry();
@@ -397,7 +397,7 @@ typedef BaseTemplateClass<TypeOne> TypeOneClass;
 
     QVERIFY(one->hasTemplateBaseClassInstantiations());
     AbstractMetaTypeList instantiations = one->templateBaseClassInstantiations();
-    QCOMPARE(instantiations.count(), 1);
+    QCOMPARE(instantiations.size(), 1);
     const AbstractMetaType &inst = instantiations.constFirst();
     QVERIFY(!inst.isEnum());
     QVERIFY(!inst.typeEntry()->isEnum());
@@ -430,7 +430,7 @@ typedef Vector<int> IntVector;
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 1);
+    QCOMPARE(classes.size(), 1);
 
     AbstractMetaClass* vector = AbstractMetaClass::findClass(classes, QLatin1String("IntVector"));
     QVERIFY(vector);
@@ -438,7 +438,7 @@ typedef Vector<int> IntVector;
     QVERIFY(baseContainer);
     QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer)->containerKind(),
              ContainerTypeEntry::ListContainer);
-    QCOMPARE(vector->functions().count(), 4);
+    QCOMPARE(vector->functions().size(), 4);
 
     const auto method = vector->findFunction(QLatin1String("method"));
     QVERIFY(!method.isNull());
@@ -474,7 +474,7 @@ Array<int, 2> foo();
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
     QVERIFY(!builder.isNull());
     auto functions = builder->globalFunctions();
-    QCOMPARE(functions.count(), 1);
+    QCOMPARE(functions.size(), 1);
     auto foo = functions.constFirst();
     QCOMPARE(foo->name(), QLatin1String("foo"));
     QCOMPARE(foo->type().name(), QLatin1String("Array"));
@@ -633,7 +633,7 @@ public:
     QVERIFY(testClass);
 
     auto fields = testClass->fields();
-    QCOMPARE(fields.count(), 1);
+    QCOMPARE(fields.size(), 1);
     auto fieldType = testClass->fields().at(0).type();
     QCOMPARE(fieldType.name(), QLatin1String("Container1"));
     QCOMPARE(fieldType.instantiations().size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
index 6d155dacc..475f709e8 100644
--- a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
@@ -47,7 +47,7 @@ void TestVoidArg::testVoidParsedFunction()
     QVERIFY(classA);
     const auto addedFunc = classA->findFunction(QLatin1String("a"));
     QVERIFY(!addedFunc.isNull());
-    QCOMPARE(addedFunc->arguments().count(), 0);
+    QCOMPARE(addedFunc->arguments().size(), 0);
 }
 
 void TestVoidArg::testVoidAddedFunction()
@@ -66,7 +66,7 @@ void TestVoidArg::testVoidAddedFunction()
     QVERIFY(classA);
     const auto addedFunc = classA->findFunction(QLatin1String("a"));
     QVERIFY(!addedFunc.isNull());
-    QCOMPARE(addedFunc->arguments().count(), 0);
+    QCOMPARE(addedFunc->arguments().size(), 0);
 
 }
 
@@ -84,7 +84,7 @@ void TestVoidArg::testVoidPointerParsedFunction()
     QVERIFY(classA);
     const auto addedFunc = classA->findFunction(QLatin1String("a"));
     QVERIFY(!addedFunc.isNull());
-    QCOMPARE(addedFunc->arguments().count(), 1);
+    QCOMPARE(addedFunc->arguments().size(), 1);
 
 }
 
diff --git a/sources/shiboken6/ApiExtractor/typedatabase.cpp b/sources/shiboken6/ApiExtractor/typedatabase.cpp
index cf9eb2404..015769cfa 100644
--- a/sources/shiboken6/ApiExtractor/typedatabase.cpp
+++ b/sources/shiboken6/ApiExtractor/typedatabase.cpp
@@ -651,8 +651,7 @@ QString TypeDatabase::globalNamespaceClassName(const TypeEntry * /*entry*/)
 FunctionModificationList TypeDatabase::functionModifications(const QString& signature) const
 {
     FunctionModificationList lst;
-    for (int i = 0; i < m_functionMods.count(); ++i) {
-        const FunctionModification& mod = m_functionMods.at(i);
+    for (const auto &mod : m_functionMods) {
         if (mod.matches(signature))
             lst << mod;
     }
diff --git a/sources/shiboken6/ApiExtractor/typesystem.cpp b/sources/shiboken6/ApiExtractor/typesystem.cpp
index 17dc83b70..da320088b 100644
--- a/sources/shiboken6/ApiExtractor/typesystem.cpp
+++ b/sources/shiboken6/ApiExtractor/typesystem.cpp
@@ -1304,8 +1304,7 @@ FunctionModificationList ComplexTypeEntry::functionModifications(const QString &
 {
     S_D(const ComplexTypeEntry);
     FunctionModificationList lst;
-    for (int i = 0; i < d->m_functionMods.count(); ++i) {
-        const FunctionModification &mod = d->m_functionMods.at(i);
+    for (const auto &mod : std::as_const(d->m_functionMods)) {
         if (mod.matches(signature))
             lst << mod;
     }