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

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

  auto QtContainerClass = 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: I2b14fe7f6a317f340e306b53930db98ec8d10098
Reviewed-by: Sona Kurazyan <kurazyan.sona@gmail.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

3 files changed, 32 insertions, 32 deletions

diff --git a/src/core5/text/qregexp.cpp b/src/core5/text/qregexp.cpp
index 91fe062..21db3f2 100644
--- a/src/core5/text/qregexp.cpp
+++ b/src/core5/text/qregexp.cpp
@@ -730,7 +730,7 @@ static void mergeInto(QList<int> *a, const QList<int> &b)
 */
 static QString wc2rx(const QString &wc_str, const bool enableEscaping)
 {
-    const int wclen = wc_str.length();
+    const int wclen = wc_str.size();
     QString rx;
     int i = 0;
     bool isEscaping = false; // the previous character is '\'
@@ -1316,7 +1316,7 @@ QRegExpEngine::QRegExpEngine(const QRegExpEngineKey &key)
 
     QString rx = qt_regexp_toCanonical(key.pattern, key.patternSyntax);
 
-    valid = (parse(rx.unicode(), rx.length()) == rx.length());
+    valid = (parse(rx.unicode(), rx.size()) == rx.size());
     if (!valid) {
 #ifndef QT_NO_REGEXP_OPTIM
         trivial = false;
@@ -1388,8 +1388,8 @@ void QRegExpMatchState::match(const QChar *str0, int len0, int pos0,
 #ifndef QT_NO_REGEXP_OPTIM
     if (eng->trivial && !oneTest) {
         // ### Qt6: qsizetype
-        pos = int(QtPrivate::findString(QStringView(str0, len0), pos0, QStringView(eng->goodStr.unicode(), eng->goodStr.length()), eng->cs));
-        matchLen = eng->goodStr.length();
+        pos = int(QtPrivate::findString(QStringView(str0, len0), pos0, QStringView(eng->goodStr.unicode(), eng->goodStr.size()), eng->cs));
+        matchLen = eng->goodStr.size();
         matched = (pos != -1);
     } else
 #endif
@@ -1594,7 +1594,7 @@ void QRegExpEngine::heuristicallyChooseHeuristic()
           proportion of the minimum-length string, and appear at a
           more-or-less known index.
         */
-        int goodStringScore = (64 * goodStr.length() / minl) -
+        int goodStringScore = (64 * goodStr.size() / minl) -
                               (goodLateStart - goodEarlyStart);
         /*
           Less magic formula: We pick some characters at random, and
@@ -1841,7 +1841,7 @@ bool QRegExpMatchState::testAnchor(int i, int a, const int *capBegin)
 bool QRegExpEngine::goodStringMatch(QRegExpMatchState &matchState) const
 {
     int k = matchState.pos + goodEarlyStart;
-    QStringMatcher matcher(goodStr.unicode(), goodStr.length(), cs);
+    QStringMatcher matcher(goodStr.unicode(), goodStr.size(), cs);
     while ((k = matcher.indexIn(matchState.in, matchState.len, k)) != -1) {
         int from = k - goodLateStart;
         int to = k - goodEarlyStart;
@@ -2225,7 +2225,7 @@ bool QRegExpMatchState::matchHere()
           It's time to wake up the sleepers.
         */
         j = 0;
-        while (j < sleeping.count()) {
+        while (j < sleeping.size()) {
             if (sleeping.at(j)[0] == i) {
                 const QList<int> &zzZ = sleeping.at(j);
                 int next = zzZ[1];
@@ -2519,22 +2519,22 @@ void QRegExpEngine::Box::cat(const Box &b)
 
 #ifndef QT_NO_REGEXP_OPTIM
     if (maxl != InftyLen) {
-        if (rightStr.length() + b.leftStr.length() >
-             qMax(str.length(), b.str.length())) {
-            earlyStart = minl - rightStr.length();
-            lateStart = maxl - rightStr.length();
+        if (rightStr.size() + b.leftStr.size() >
+             qMax(str.size(), b.str.size())) {
+            earlyStart = minl - rightStr.size();
+            lateStart = maxl - rightStr.size();
             str = rightStr + b.leftStr;
-        } else if (b.str.length() > str.length()) {
+        } else if (b.str.size() > str.size()) {
             earlyStart = minl + b.earlyStart;
             lateStart = maxl + b.lateStart;
             str = b.str;
         }
     }
 
-    if (leftStr.length() == maxl)
+    if (leftStr.size() == maxl)
         leftStr += b.leftStr;
 
-    if (b.rightStr.length() == b.maxl) {
+    if (b.rightStr.size() == b.maxl) {
         rightStr += b.rightStr;
     } else {
         rightStr = b.rightStr;
@@ -3079,7 +3079,7 @@ int QRegExpEngine::getEscape()
             }
             yyCh = getChar(); // skip closing '}'
 
-            int catlen = category.length();
+            int catlen = category.size();
             if (catlen == 1 || catlen == 2) {
                 switch (category.at(0)) {
                 case 'M':
@@ -3549,7 +3549,7 @@ int QRegExpEngine::parse(const QChar *pattern, int len)
 #endif
 
     // cleanup anchors
-    int numStates = s.count();
+    int numStates = s.size();
     for (int i = 0; i < numStates; ++i) {
         QRegExpAutomatonState &state = s[i];
         if (!state.anchors.isEmpty()) {
@@ -3789,7 +3789,7 @@ static void derefEngine(QRegExpEngine *eng, const QRegExpEngineKey &key)
     const auto locker = qt_scoped_lock(engineCacheMutex);
     if (!eng->ref.deref()) {
         if (QRECache *c = engineCache()) {
-            c->unusedEngines.insert(key, eng, 4 + key.pattern.length() / 4);
+            c->unusedEngines.insert(key, eng, 4 + key.pattern.size() / 4);
             c->usedEngines.remove(key);
         } else {
             delete eng;
@@ -4211,8 +4211,8 @@ void QRegExp::setMinimal(bool minimal)
 bool QRegExp::exactMatch(const QString &str) const
 {
     prepareEngineForMatch(priv, str);
-    priv->matchState.match(str.unicode(), str.length(), 0, priv->minimal, true, 0);
-    if (priv->matchState.captured[1] == str.length()) {
+    priv->matchState.match(str.unicode(), str.size(), 0, priv->minimal, true, 0);
+    if (priv->matchState.captured[1] == str.size()) {
         return true;
     } else {
         priv->matchState.captured[0] = 0;
@@ -4266,8 +4266,8 @@ int QRegExp::indexIn(const QString &str, int offset, CaretMode caretMode) const
 {
     prepareEngineForMatch(priv, str);
     if (offset < 0)
-        offset += str.length();
-    priv->matchState.match(str.unicode(), str.length(), offset,
+        offset += str.size();
+    priv->matchState.match(str.unicode(), str.size(), offset,
         priv->minimal, false, caretIndex(offset, caretMode));
     return priv->matchState.captured[0];
 }
@@ -4297,14 +4297,14 @@ int QRegExp::lastIndexIn(const QString &str, int offset, CaretMode caretMode) co
 {
     prepareEngineForMatch(priv, str);
     if (offset < 0)
-        offset += str.length();
-    if (offset < 0 || offset > str.length()) {
+        offset += str.size();
+    if (offset < 0 || offset > str.size()) {
         memset(priv->matchState.captured, -1, priv->matchState.capturedSize*sizeof(int));
         return -1;
     }
 
     while (offset >= 0) {
-        priv->matchState.match(str.unicode(), str.length(), offset,
+        priv->matchState.match(str.unicode(), str.size(), offset,
             priv->minimal, true, caretIndex(offset, caretMode));
         if (priv->matchState.captured[0] == offset)
             return offset;
@@ -4353,7 +4353,7 @@ QString QRegExp::replaceIn(const QString &str, const QString &after) const
 
     int index = 0;
     int numCaptures = rx2.captureCount();
-    int al = after.length();
+    int al = after.size();
     QRegExp::CaretMode caretMode = QRegExp::CaretAtZero;
 
     if (numCaptures > 0) {
@@ -4397,7 +4397,7 @@ QString QRegExp::replaceIn(const QString &str, const QString &after) const
                 }
             }
 
-            while (index <= s.length()) {
+            while (index <= s.size()) {
                 index = rx2.indexIn(s, index, caretMode);
                 if (index == -1)
                     break;
@@ -4409,7 +4409,7 @@ QString QRegExp::replaceIn(const QString &str, const QString &after) const
                 }
 
                 s.replace(index, rx2.matchedLength(), after2);
-                index += after2.length();
+                index += after2.size();
 
                 // avoid infinite loop on 0-length matches (e.g., QRegExp("[a-z]*"))
                 if (rx2.matchedLength() == 0)
@@ -4507,7 +4507,7 @@ int QRegExp::countIn(const QString &str) const
     QRegExp rx2(*this);
     int count = 0;
     int index = -1;
-    int len = str.length();
+    int len = str.size();
     while (index < len - 1) {                 // count overlapping matches
         index = rx2.indexIn(str, index + 1);
         if (index == -1)
diff --git a/src/core5/text/qstringref.cpp b/src/core5/text/qstringref.cpp
index 288372a..b366d05 100644
--- a/src/core5/text/qstringref.cpp
+++ b/src/core5/text/qstringref.cpp
@@ -182,7 +182,7 @@ static QByteArray qt_convert_to_utf8(QStringView str)
 
 static QList<uint> qt_convert_to_ucs4(QStringView string)
 {
-    QList<uint> v(string.length());
+    QList<uint> v(string.size());
     uint *a = const_cast<uint*>(v.constData());
     QStringIterator it(string);
     while (it.hasNext())
@@ -1182,7 +1182,7 @@ QStringRef QStringRef::mid(int pos, int n) const
 int QStringRef::indexOf(const QString &str, int from, Qt::CaseSensitivity cs) const
 {
     // ### Qt6: qsizetype
-    return int(QtPrivate::findString(QStringView(unicode(), length()), from, QStringView(str.unicode(), str.length()), cs));
+    return int(QtPrivate::findString(QStringView(unicode(), length()), from, QStringView(str.unicode(), str.size()), cs));
 }
 
 /*!
diff --git a/src/core5/text/qstringref.h b/src/core5/text/qstringref.h
index de85b97..b4474da 100644
--- a/src/core5/text/qstringref.h
+++ b/src/core5/text/qstringref.h
@@ -280,13 +280,13 @@ inline bool operator<=(const QStringRef &lhs, const QString &rhs) noexcept { ret
 inline bool operator>=(const QStringRef &lhs, const QString &rhs) noexcept { return rhs <= lhs; }
 
 inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const noexcept
-{ return QStringRef::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+{ return QStringRef::compare_helper(constData(), length(), s.constData(), s.size(), cs); }
 inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const noexcept
 { return QStringRef::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
 inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const noexcept
 { return QStringRef::compare_helper(constData(), length(), s, cs); }
 inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs) noexcept
-{ return QStringRef::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+{ return QStringRef::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.size(), cs); }
 inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs) noexcept
 { return QStringRef::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
 inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs) noexcept