Port from container::count() and length() to size()

This is a semantic patch using ClangTidyTransformator as in
qtbase/df9d882d41b741fef7c5beeddb0abe9d904443d8:

  auto QtContainerClass = anyOf(
      expr(hasType(cxxRecordDecl(isSameOrDerivedFrom(hasAnyName(classes))))).bind(o),
      expr(hasType(namedDecl(hasAnyName(<classes>)))).bind(o));
  makeRule(cxxMemberCallExpr(on(QtContainerClass),
                             callee(cxxMethodDecl(hasAnyName({"count", "length"),
                                                  parameterCountIs(0))))),
           changeTo(cat(access(o, cat("size"), "()"))),
           cat("use 'size()' instead of 'count()/length()'"))

a.k.a qt-port-to-std-compatible-api with config Scope: 'Container',
with the extended set of container classes recognized.

Change-Id: Iaf46b2ba54f3b125aee087c2cacb702d8d564201
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

4 files changed, 66 insertions, 66 deletions

diff --git a/tools/qscxmlc/generator.cpp b/tools/qscxmlc/generator.cpp
index 3027912..419e5da 100644
--- a/tools/qscxmlc/generator.cpp
+++ b/tools/qscxmlc/generator.cpp
@@ -100,23 +100,23 @@ Generator::Generator(ClassDef *classDef, const QList<QByteArray> &metaTypes,
 
 static inline int lengthOfEscapeSequence(const QByteArray &s, int i)
 {
-    if (s.at(i) != '\\' || i >= s.length() - 1)
+    if (s.at(i) != '\\' || i >= s.size() - 1)
         return 1;
     const int startPos = i;
     ++i;
     char ch = s.at(i);
     if (ch == 'x') {
         ++i;
-        while (i < s.length() && is_hex_char(s.at(i)))
+        while (i < s.size() && is_hex_char(s.at(i)))
             ++i;
     } else if (is_octal_char(ch)) {
         while (i < startPos + 4
-               && i < s.length()
+               && i < s.size()
                && is_octal_char(s.at(i))) {
             ++i;
         }
     } else { // single character escape sequence
-        i = qMin(i + 1, s.length());
+        i = qMin(i + 1, s.size());
     }
     return i - startPos;
 }
@@ -140,8 +140,8 @@ int Generator::stridx(const QByteArray &s)
 static int aggregateParameterCount(const QList<FunctionDef> &list)
 {
     int sum = 0;
-    for (int i = 0; i < list.count(); ++i)
-        sum += list.at(i).arguments.count() + 1; // +1 for return type
+    for (int i = 0; i < list.size(); ++i)
+        sum += list.at(i).arguments.size() + 1; // +1 for return type
     return sum;
 }
 
@@ -212,7 +212,7 @@ void Generator::generateCode()
     // filter out undeclared enumerators and sets
     {
         QList<EnumDef> enumList;
-        for (int i = 0; i < cdef->enumList.count(); ++i) {
+        for (int i = 0; i < cdef->enumList.size(); ++i) {
             EnumDef def = cdef->enumList.at(i);
             if (cdef->enumDeclarations.contains(def.name)) {
                 enumList += def;
@@ -253,7 +253,7 @@ void Generator::generateCode()
         int stringDataLength = 0;
         int stringDataCounter = 0;
         for (int i = 0; i < strings.size(); ++i) {
-            int thisLength = strings.at(i).length() + 1;
+            int thisLength = strings.at(i).size() + 1;
             stringDataLength += thisLength;
             if (stringDataLength / constCharArraySizeLimit) {
                 // save previous stringdata and start computing the next one.
@@ -286,13 +286,13 @@ void Generator::generateCode()
         int idx = 0;
         for (int i = 0; i < strings.size(); ++i) {
             const QByteArray &str = strings.at(i);
-            fprintf(out, "QT_MOC_LITERAL(%d, %d)", idx, int(str.length()));
+            fprintf(out, "QT_MOC_LITERAL(%d, %d)", idx, int(str.size()));
             if (i != strings.size() - 1)
                 fputc(',', out);
-            const QByteArray comment = str.length() > 32 ? str.left(29) + "..." : str;
+            const QByteArray comment = str.size() > 32 ? str.left(29) + "..." : str;
             fprintf(out, " // \"%s\"\n", comment.size() ? comment.constData() : "");
-            idx += str.length() + 1;
-            for (int j = 0; j < str.length(); ++j) {
+            idx += str.size() + 1;
+            for (int j = 0; j < str.size(); ++j) {
                 if (str.at(j) == '\\') {
                     int cnt = lengthOfEscapeSequence(str, j) - 1;
                     idx -= cnt;
@@ -309,7 +309,7 @@ void Generator::generateCode()
 // -- QtScxml
     for (int i = 0; i < strings.size(); ++i) {
         QByteArray s = strings.at(i);
-        int len = s.length();
+        int len = s.size();
         for (int charPos = 0; charPos < len; ++charPos)
             fprintf(out, "0x%.2x,", static_cast<quint8>(s.at(charPos)));
         fprintf(out, "0%s // %d: %s\n", i < strings.size() - 1 ? "," : "", i, s.constData());
@@ -329,10 +329,10 @@ void Generator::generateCode()
     fprintf(out, "\n // content:\n");
     fprintf(out, "    %4d,       // revision\n", int(QMetaObjectPrivate::OutputRevision));
     fprintf(out, "    %4d,       // classname\n", stridx(cdef->qualified));
-    fprintf(out, "    %4d, %4d, // classinfo\n", int(cdef->classInfoList.count()), int(cdef->classInfoList.count() ? index : 0));
-    index += cdef->classInfoList.count() * 2;
+    fprintf(out, "    %4d, %4d, // classinfo\n", int(cdef->classInfoList.size()), int(cdef->classInfoList.size() ? index : 0));
+    index += cdef->classInfoList.size() * 2;
 
-    int methodCount = cdef->signalList.count() + cdef->slotList.count() + cdef->methodList.count();
+    int methodCount = cdef->signalList.size() + cdef->slotList.size() + cdef->methodList.size();
     fprintf(out, "    %4d, %4d, // methods\n", methodCount, methodCount ? index : 0);
     index += methodCount * QMetaObjectPrivate::IntsPerMethod;
     if (cdef->revisionedMethods)
@@ -344,16 +344,16 @@ void Generator::generateCode()
             + aggregateParameterCount(cdef->constructorList);
     index += totalParameterCount * 2 // types and parameter names
             - methodCount // return "parameters" don't have names
-            - cdef->constructorList.count(); // "this" parameters don't have names
+            - cdef->constructorList.size(); // "this" parameters don't have names
 
-    fprintf(out, "    %4d, %4d, // properties\n", int(cdef->propertyList.count()), int(cdef->propertyList.count() ? index : 0));
-    index += cdef->propertyList.count() * QMetaObjectPrivate::IntsPerProperty;
-    fprintf(out, "    %4d, %4d, // enums/sets\n", int(cdef->enumList.count()), cdef->enumList.count() ? index : 0);
+    fprintf(out, "    %4d, %4d, // properties\n", int(cdef->propertyList.size()), int(cdef->propertyList.size() ? index : 0));
+    index += cdef->propertyList.size() * QMetaObjectPrivate::IntsPerProperty;
+    fprintf(out, "    %4d, %4d, // enums/sets\n", int(cdef->enumList.size()), cdef->enumList.size() ? index : 0);
 
     int enumsIndex = index;
-    for (int i = 0; i < cdef->enumList.count(); ++i)
-        index += 5 + (cdef->enumList.at(i).values.count() * 2);
-    fprintf(out, "    %4d, %4d, // constructors\n", isConstructible ? int(cdef->constructorList.count()) : 0,
+    for (int i = 0; i < cdef->enumList.size(); ++i)
+        index += 5 + (cdef->enumList.at(i).values.size() * 2);
+    fprintf(out, "    %4d, %4d, // constructors\n", isConstructible ? int(cdef->constructorList.size()) : 0,
             isConstructible ? index : 0);
 
     int flags = 0;
@@ -363,7 +363,7 @@ void Generator::generateCode()
         flags |= PropertyAccessInStaticMetaCall;
     }
     fprintf(out, "    %4d,       // flags\n", flags);
-    fprintf(out, "    %4d,       // signalCount\n", int(cdef->signalList.count()));
+    fprintf(out, "    %4d,       // signalCount\n", int(cdef->signalList.size()));
 
 
 //
@@ -371,7 +371,7 @@ void Generator::generateCode()
 //
     generateClassInfos();
 
-    int initialMetaTypeOffset = cdef->propertyList.count();
+    int initialMetaTypeOffset = cdef->propertyList.size();
 
 //
 // Build signals array first, otherwise the signal indices would be wrong
@@ -443,7 +443,7 @@ void Generator::generateCode()
     QMultiHash<QByteArray, QByteArray> knownExtraMetaObject(knownGadgets);
     knownExtraMetaObject.unite(knownQObjectClasses);
 
-    for (int i = 0; i < cdef->propertyList.count(); ++i) {
+    for (int i = 0; i < cdef->propertyList.size(); ++i) {
         const PropertyDef &p = cdef->propertyList.at(i);
         if (isBuiltinType(p.type))
             continue;
@@ -503,7 +503,7 @@ void Generator::generateCode()
     if (!extraList.isEmpty()) {
         fprintf(out, "static const QMetaObject::SuperData qt_meta_extradata_%s[] = {\n",
                 qualifiedClassNameIdentifier.constData());
-        for (int i = 0; i < extraList.count(); ++i) {
+        for (int i = 0; i < extraList.size(); ++i) {
             fprintf(out, "    QMetaObject::SuperData::link<%s::staticMetaObject>(),\n", extraList.at(i).constData());
         }
         fprintf(out, "    nullptr\n};\n\n");
@@ -536,9 +536,9 @@ void Generator::generateCode()
         fprintf(out, "    qt_meta_extradata_%s,\n", qualifiedClassNameIdentifier.constData());
 
     bool constructorListContainsArgument = false;
-    for (int i = 0; i< cdef->constructorList.count(); ++i) {
+    for (int i = 0; i< cdef->constructorList.size(); ++i) {
         const FunctionDef& fdef = cdef->constructorList.at(i);
-        if (fdef.arguments.count()) {
+        if (fdef.arguments.size()) {
             constructorListContainsArgument = true;
             break;
         }
@@ -554,7 +554,7 @@ void Generator::generateCode()
         } else {
             fprintf(out, "qt_metaTypeArray<\n");
         }
-        for (int i = 0; i < cdef->propertyList.count(); ++i) {
+        for (int i = 0; i < cdef->propertyList.size(); ++i) {
             const PropertyDef &p = cdef->propertyList.at(i);
             if (requireCompleteness)
                 fprintf(out, "%s%s", needsComma ? ", " : "", p.type.data());
@@ -564,7 +564,7 @@ void Generator::generateCode()
         }
         for (const QList<FunctionDef> &methodContainer :
              { cdef->signalList, cdef->slotList, cdef->methodList }) {
-            for (int i = 0; i< methodContainer.count(); ++i) {
+            for (int i = 0; i< methodContainer.size(); ++i) {
                 const FunctionDef& fdef = methodContainer.at(i);
                 if (requireCompleteness)
                     fprintf(out, "%s%s", needsComma ? ", " : "", fdef.type.name.data());
@@ -580,7 +580,7 @@ void Generator::generateCode()
             }
             fprintf(out, "\n");
         }
-        for (int i = 0; i< cdef->constructorList.count(); ++i) {
+        for (int i = 0; i< cdef->constructorList.size(); ++i) {
             const FunctionDef& fdef = cdef->constructorList.at(i);
             for (const auto &argument: fdef.arguments) {
                 if (requireCompleteness)
@@ -695,7 +695,7 @@ void Generator::generateClassInfos()
 
 void Generator::registerFunctionStrings(const QList<FunctionDef> &list)
 {
-    for (int i = 0; i < list.count(); ++i) {
+    for (int i = 0; i < list.size(); ++i) {
         const FunctionDef &f = list.at(i);
 
         strreg(f.name);
@@ -703,7 +703,7 @@ void Generator::registerFunctionStrings(const QList<FunctionDef> &list)
             strreg(f.normalizedType);
         strreg(f.tag);
 
-        int argsCount = f.arguments.count();
+        int argsCount = f.arguments.size();
         for (int j = 0; j < argsCount; ++j) {
             const ArgumentDef &a = f.arguments.at(j);
             if (!isBuiltinType(a.normalizedType))
@@ -726,7 +726,7 @@ void Generator::generateFunctions(const QList<FunctionDef> &list, const char *fu
         return;
     fprintf(out, "\n // %ss: name, argc, parameters, tag, flags, initial metatype offsets\n", functype);
 
-    for (int i = 0; i < list.count(); ++i) {
+    for (int i = 0; i < list.size(); ++i) {
         const FunctionDef &f = list.at(i);
 
         QByteArray comment;
@@ -758,7 +758,7 @@ void Generator::generateFunctions(const QList<FunctionDef> &list, const char *fu
             comment.append(" | MethodRevisioned");
         }
 
-        int argc = f.arguments.count();
+        int argc = f.arguments.size();
         fprintf(out, "    %4d, %4d, %4d, %4d, 0x%02x, %4d /* %s */,\n",
             stridx(f.name), argc, paramsIndex, stridx(f.tag), flags, initialMetatypeOffset, comment.constData());
 
@@ -770,9 +770,9 @@ void Generator::generateFunctions(const QList<FunctionDef> &list, const char *fu
 
 void Generator::generateFunctionRevisions(const QList<FunctionDef> &list, const char *functype)
 {
-    if (list.count())
+    if (list.size())
         fprintf(out, "\n // %ss: revision\n", functype);
-    for (int i = 0; i < list.count(); ++i) {
+    for (int i = 0; i < list.size(); ++i) {
         const FunctionDef &f = list.at(i);
         fprintf(out, "    %4d,\n", f.revision);
     }
@@ -783,12 +783,12 @@ void Generator::generateFunctionParameters(const QList<FunctionDef> &list, const
     if (list.isEmpty())
         return;
     fprintf(out, "\n // %ss: parameters\n", functype);
-    for (int i = 0; i < list.count(); ++i) {
+    for (int i = 0; i < list.size(); ++i) {
         const FunctionDef &f = list.at(i);
         fprintf(out, "    ");
 
         // Types
-        int argsCount = f.arguments.count();
+        int argsCount = f.arguments.size();
         for (int j = -1; j < argsCount; ++j) {
             if (j > -1)
                 fputc(' ', out);
@@ -834,7 +834,7 @@ void Generator::generateTypeInfo(const QByteArray &typeName, bool allowEmptyName
 
 void Generator::registerPropertyStrings()
 {
-    for (int i = 0; i < cdef->propertyList.count(); ++i) {
+    for (int i = 0; i < cdef->propertyList.size(); ++i) {
         const PropertyDef &p = cdef->propertyList.at(i);
         strreg(p.name);
         if (!isBuiltinType(p.type))
@@ -848,9 +848,9 @@ void Generator::generateProperties()
     // Create meta data
     //
 
-    if (cdef->propertyList.count())
+    if (cdef->propertyList.size())
         fprintf(out, "\n // properties: name, type, flags\n");
-    for (int i = 0; i < cdef->propertyList.count(); ++i) {
+    for (int i = 0; i < cdef->propertyList.size(); ++i) {
         const PropertyDef &p = cdef->propertyList.at(i);
         uint flags = Invalid;
         if (!isBuiltinType(p.type))
@@ -904,12 +904,12 @@ void Generator::generateProperties()
 
 void Generator::registerEnumStrings()
 {
-    for (int i = 0; i < cdef->enumList.count(); ++i) {
+    for (int i = 0; i < cdef->enumList.size(); ++i) {
         const EnumDef &e = cdef->enumList.at(i);
         strreg(e.name);
         if (!e.enumName.isNull())
             strreg(e.enumName);
-        for (int j = 0; j < e.values.count(); ++j)
+        for (int j = 0; j < e.values.size(); ++j)
             strreg(e.values.at(j));
     }
 }
@@ -920,9 +920,9 @@ void Generator::generateEnums(int index)
         return;
 
     fprintf(out, "\n // enums: name, alias, flags, count, data\n");
-    index += 5 * cdef->enumList.count();
+    index += 5 * cdef->enumList.size();
     int i;
-    for (i = 0; i < cdef->enumList.count(); ++i) {
+    for (i = 0; i < cdef->enumList.size(); ++i) {
         const EnumDef &e = cdef->enumList.at(i);
         int flags = 0;
         if (cdef->enumDeclarations.value(e.name))
@@ -933,15 +933,15 @@ void Generator::generateEnums(int index)
                  stridx(e.name),
                  e.enumName.isNull() ? stridx(e.name) : stridx(e.enumName),
                  flags,
-                 int(e.values.count()),
+                 int(e.values.size()),
                  index);
-        index += e.values.count() * 2;
+        index += e.values.size() * 2;
     }
 
     fprintf(out, "\n // enum data: key, value\n");
-    for (i = 0; i < cdef->enumList.count(); ++i) {
+    for (i = 0; i < cdef->enumList.size(); ++i) {
         const EnumDef &e = cdef->enumList.at(i);
-        for (int j = 0; j < e.values.count(); ++j) {
+        for (int j = 0; j < e.values.size(); ++j) {
             const QByteArray &val = e.values.at(j);
             QByteArray code = cdef->qualified.constData();
             if (e.isEnumClass)
@@ -1009,7 +1009,7 @@ void Generator::generateMetacall()
             "            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty\n"
             "            || _c == QMetaObject::RegisterPropertyMetaType) {\n"
             "        qt_static_metacall(this, _c, _id, _a);\n"
-            "        _id -= %d;\n    }", int(cdef->propertyList.count()));
+            "        _id -= %d;\n    }", int(cdef->propertyList.size()));
         fprintf(out, "\n#endif // QT_NO_PROPERTIES");
     }
     if (methodList.size() || cdef->propertyList.size())
@@ -1035,7 +1035,7 @@ Generator::methodsWithAutomaticTypesHelper(const QList<FunctionDef> &methodList)
     QMap<int, QMultiMap<QByteArray, int> > methodsWithAutomaticTypes;
     for (int i = 0; i < methodList.size(); ++i) {
         const FunctionDef &f = methodList.at(i);
-        for (int j = 0; j < f.arguments.count(); ++j) {
+        for (int j = 0; j < f.arguments.size(); ++j) {
             const QByteArray argType = f.arguments.at(j).normalizedType;
             if (registerableMetaType(argType) && !isBuiltinType(argType))
                 methodsWithAutomaticTypes[i].insert(argType, j);
@@ -1055,13 +1055,13 @@ void Generator::generateStaticMetacall()
     if (!cdef->constructorList.isEmpty()) {
         fprintf(out, "    if (_c == QMetaObject::CreateInstance) {\n");
         fprintf(out, "        switch (_id) {\n");
-        for (int ctorindex = 0; ctorindex < cdef->constructorList.count(); ++ctorindex) {
+        for (int ctorindex = 0; ctorindex < cdef->constructorList.size(); ++ctorindex) {
             fprintf(out, "        case %d: { %s *_r = new %s(", ctorindex,
                     cdef->classname.constData(), cdef->classname.constData());
             const FunctionDef &f = cdef->constructorList.at(ctorindex);
             int offset = 1;
 
-            int argsCount = f.arguments.count();
+            int argsCount = f.arguments.size();
             for (int j = 0; j < argsCount; ++j) {
                 const ArgumentDef &a = f.arguments.at(j);
                 if (j)
@@ -1127,7 +1127,7 @@ void Generator::generateStaticMetacall()
             if (f.isRawSlot) {
                 fprintf(out, "QMethodRawArguments{ _a }");
             } else {
-                int argsCount = f.arguments.count();
+                int argsCount = f.arguments.size();
                 for (int j = 0; j < argsCount; ++j) {
                     const ArgumentDef &a = f.arguments.at(j);
                     if (j)
@@ -1201,7 +1201,7 @@ void Generator::generateStaticMetacall()
             fprintf(out, "        {\n");
             fprintf(out, "            using _t = %s (%s::*)(",f.type.rawName.constData() , cdef->classname.constData());
 
-            int argsCount = f.arguments.count();
+            int argsCount = f.arguments.size();
             for (int j = 0; j < argsCount; ++j) {
                 const ArgumentDef &a = f.arguments.at(j);
                 if (j)
@@ -1462,7 +1462,7 @@ void Generator::generateSignal(FunctionDef *def,int index)
     }
 
     int offset = 1;
-    for (int j = 0; j < def->arguments.count(); ++j) {
+    for (int j = 0; j < def->arguments.size(); ++j) {
         const ArgumentDef &a = def->arguments.at(j);
         if (j)
             fputs(", ", out);
@@ -1493,7 +1493,7 @@ void Generator::generateSignal(FunctionDef *def,int index)
     }
     int i;
     for (i = 1; i < offset; ++i)
-        if (i <= def->arguments.count() && def->arguments.at(i - 1).type.isVolatile)
+        if (i <= def->arguments.size() && def->arguments.at(i - 1).type.isVolatile)
             fprintf(out, ", const_cast<void*>(reinterpret_cast<const volatile void*>(std::addressof(_t%d)))", i);
         else
             fprintf(out, ", const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t%d)))", i);
diff --git a/tools/qscxmlc/moc.h b/tools/qscxmlc/moc.h
index 6486ca8..de3778f 100644
--- a/tools/qscxmlc/moc.h
+++ b/tools/qscxmlc/moc.h
@@ -287,8 +287,8 @@ inline QByteArray noRef(const QByteArray &type)
 {
     if (type.endsWith('&')) {
         if (type.endsWith("&&"))
-            return type.left(type.length()-2);
-        return type.left(type.length()-1);
+            return type.left(type.size()-2);
+        return type.left(type.size()-1);
     }
     return type;
 }
diff --git a/tools/qscxmlc/qscxmlc.cpp b/tools/qscxmlc/qscxmlc.cpp
index 63898a4..f8e7a15 100644
--- a/tools/qscxmlc/qscxmlc.cpp
+++ b/tools/qscxmlc/qscxmlc.cpp
@@ -113,12 +113,12 @@ int run(const QStringList &arguments)
 
     const QStringList inputFiles = cmdParser.positionalArguments();
 
-    if (inputFiles.count() < 1) {
+    if (inputFiles.size() < 1) {
         errs << QCoreApplication::translate("main", "Error: no input file.") << Qt::endl;
         cmdParser.showHelp(NoInputFilesError);
     }
 
-    if (inputFiles.count() > 1) {
+    if (inputFiles.size() > 1) {
         errs << QCoreApplication::translate("main", "Error: unexpected argument(s): %1")
                 .arg(inputFiles.mid(1).join(QLatin1Char(' '))) << Qt::endl;
         cmdParser.showHelp(NoInputFilesError);
diff --git a/tools/qscxmlc/scxmlcppdumper.cpp b/tools/qscxmlc/scxmlcppdumper.cpp
index 6154446..5e19d33 100644
--- a/tools/qscxmlc/scxmlcppdumper.cpp
+++ b/tools/qscxmlc/scxmlcppdumper.cpp
@@ -42,7 +42,7 @@ QString cEscape(const QString &str)
 {
     QString res;
     int lastI = 0;
-    for (int i = 0; i < str.length(); ++i) {
+    for (int i = 0; i < str.size(); ++i) {
         QChar c = str.at(i);
         if (c < QLatin1Char(' ') || c == QLatin1Char('\\') || c == QLatin1Char('\"')) {
             res.append(str.mid(lastI, i - lastI));
@@ -137,7 +137,7 @@ static void generateList(QString &out, std::function<QString(int)> next)
         if (i != 0)
             line += QLatin1Char(',');
 
-        if (line.length() + nr.length() + 1 > maxLineLength) {
+        if (line.size() + nr.size() + 1 > maxLineLength) {
             out += line + QLatin1Char('\n');
             line.clear();
         } else if (i != 0) {
@@ -652,7 +652,7 @@ QString CppDumper::mangleIdentifier(const QString &str)
         }
     }
 
-    for (int ei = str.length(); i != ei; ++i) {
+    for (int ei = str.size(); i != ei; ++i) {
         auto c = str.at(i);
         if ((c >= QLatin1Char('0') && c <= QLatin1Char('9')) || isNonDigit(c)) {
             mangled += c;