Moc/Symbols: fix narrowing conversion warnings

- Port to qsizetype
- Use range-for/algorithms instead of index-based loops

Drive-by changes:
- Methods defined in-class are implicitly "inline"
- Make two methods const (saves using std::as_const in one place), and
  there is no reason why they are not const
- For consistency initialize members in-class / in constructor init-list

Pick-to: 6.5
Change-Id: If7f1546625028cbe13339430977b19952fedbd42
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

src/tools/moc/symbols.h

@@ -19,19 +19,23 @@ QT_BEGIN_NAMESPACE
 
 struct SubArray
 {
-    inline SubArray():from(0),len(-1){}
+    inline SubArray() = default;
     inline SubArray(const QByteArray &a):array(a),from(0), len(a.size()){}
     inline SubArray(const char *s):array(s),from(0) { len = array.size(); }
-    inline SubArray(const QByteArray &a, int from, int len):array(a), from(from), len(len){}
+    SubArray(const QByteArray &a, qsizetype from, qsizetype len)
+        : array(a), from(from), len(len)
+    {
+    }
     QByteArray array;
-    int from, len;
+    qsizetype from = 0;
+    qsizetype len = -1;
     inline bool operator==(const SubArray &other) const {
         if (len != other.len)
             return false;
-        for (int i = 0; i < len; ++i)
-            if (array.at(from + i) != other.array.at(other.from + i))
-                return false;
-        return true;
+        const auto begin = array.cbegin() + from;
+        const auto end = begin + len;
+        const auto other_begin = other.array.cbegin() + other.from;
+        return std::equal(begin, end, other_begin);
     }
 };
 
@@ -73,15 +77,18 @@ struct Symbol
 
 #else
 
-    inline Symbol() : lineNum(-1),token(NOTOKEN), from(0),len(-1) {}
-    inline Symbol(int lineNum, Token token):
-        lineNum(lineNum), token(token), from(0), len(-1) {}
-    inline Symbol(int lineNum, Token token, const QByteArray &lexem):
-        lineNum(lineNum), token(token), lex(lexem), from(0) { len = lex.size(); }
-    inline Symbol(int lineNum, Token token, const QByteArray &lexem, int from, int len):
-        lineNum(lineNum), token(token),lex(lexem),from(from), len(len){}
-    int lineNum;
-    Token token;
+    inline Symbol() = default;
+    inline Symbol(int lineNum, Token token) : lineNum(lineNum), token(token) { }
+    inline Symbol(int lineNum, Token token, const QByteArray &lexem)
+        : lineNum(lineNum), token(token), lex(lexem), len(lex.size())
+    {
+    }
+    Symbol(int lineNum, Token token, const QByteArray &lexem, qsizetype from, qsizetype len)
+        : lineNum(lineNum), token(token), lex(lexem), from(from), len(len)
+    {
+    }
+    int lineNum = -1;
+    Token token = NOTOKEN;
     inline QByteArray lexem() const { return lex.mid(from, len); }
     inline QByteArray unquotedLexem() const { return lex.mid(from+1, len-2); }
     inline operator SubArray() const { return SubArray(lex, from, len); }
@@ -90,7 +97,8 @@ struct Symbol
         return SubArray(lex, from, len) == SubArray(o.lex, o.from, o.len);
     }
     QByteArray lex;
-    int from, len;
+    qsizetype from = 0;
+    qsizetype len = -1;
 
 #endif
 };
@@ -127,13 +135,13 @@ public:
     inline QByteArray lexem() const { return symbol().lexem(); }
     inline QByteArray unquotedLexem() { return symbol().unquotedLexem(); }
 
-    bool dontReplaceSymbol(const QByteArray &name);
-    QSet<QByteArray> excludeSymbols();
+    bool dontReplaceSymbol(const QByteArray &name) const;
+    QSet<QByteArray> excludeSymbols() const;
 };
 
 inline bool SymbolStack::test(Token token)
 {
-    int stackPos = size() - 1;
+    qsizetype stackPos = size() - 1;
     while (stackPos >= 0 && at(stackPos).index >= at(stackPos).symbols.size())
         --stackPos;
     if (stackPos < 0)
@@ -145,21 +153,20 @@ inline bool SymbolStack::test(Token token)
     return false;
 }
 
-inline bool SymbolStack::dontReplaceSymbol(const QByteArray &name)
+inline bool SymbolStack::dontReplaceSymbol(const QByteArray &name) const
 {
-    for (int i = 0; i < size(); ++i) {
-        if (name == at(i).expandedMacro || at(i).excludedSymbols.contains(name))
-            return true;
-    }
-    return false;
+    auto matchesName = [&name](const SafeSymbols &sf) {
+        return name == sf.expandedMacro || sf.excludedSymbols.contains(name);
+    };
+    return std::any_of(cbegin(), cend(), matchesName);
 }
 
-inline QSet<QByteArray> SymbolStack::excludeSymbols()
+inline QSet<QByteArray> SymbolStack::excludeSymbols() const
 {
     QSet<QByteArray> set;
-    for (int i = 0; i < size(); ++i) {
-        set << at(i).expandedMacro;
-        set += at(i).excludedSymbols;
+    for (const SafeSymbols &sf : *this) {
+        set << sf.expandedMacro;
+        set += sf.excludedSymbols;
     }
     return set;
 }