Generators: Replace QList by QVector

QList will be deprecated in Qt.

Change-Id: I7b1aea46f800908d775aca2610a2215e164c308e
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

9 files changed, 57 insertions, 53 deletions

diff --git a/generator/generator.cpp b/generator/generator.cpp
index b1cf5cf..76d104c 100644
--- a/generator/generator.cpp
+++ b/generator/generator.cpp
@@ -49,18 +49,14 @@ struct Generator::GeneratorPrivate {
     int numGenerated;
     QStringList instantiatedContainersNames;
     QStringList instantiatedSmartPointerNames;
-    QList<const AbstractMetaType *> instantiatedContainers;
-    QList<const AbstractMetaType *> instantiatedSmartPointers;
+    QVector<const AbstractMetaType *> instantiatedContainers;
+    QVector<const AbstractMetaType *> instantiatedSmartPointers;
 
 };
 
 Generator::Generator() : m_d(new GeneratorPrivate)
 {
     m_d->numGenerated = 0;
-    m_d->instantiatedContainers = QList<const AbstractMetaType *>();
-    m_d->instantiatedSmartPointers = QList<const AbstractMetaType *>();
-    m_d->instantiatedContainersNames = QStringList();
-    m_d->instantiatedSmartPointerNames = QStringList();
 }
 
 Generator::~Generator()
@@ -188,12 +184,12 @@ void Generator::collectInstantiatedContainersAndSmartPointers()
         collectInstantiatedContainersAndSmartPointers(metaClass);
 }
 
-QList<const AbstractMetaType*> Generator::instantiatedContainers() const
+QVector<const AbstractMetaType *> Generator::instantiatedContainers() const
 {
     return m_d->instantiatedContainers;
 }
 
-QList<const AbstractMetaType*> Generator::instantiatedSmartPointers() const
+QVector<const AbstractMetaType*> Generator::instantiatedSmartPointers() const
 {
     return m_d->instantiatedSmartPointers;
 }
@@ -676,7 +672,7 @@ QString Generator::minimalConstructor(const AbstractMetaClass* metaClass) const
     if (maxArgs == 0)
         return QLatin1String("::") + qualifiedCppName + QLatin1String("()");
 
-    QList<const AbstractMetaFunction*> candidates;
+    QVector<const AbstractMetaFunction *> candidates;
 
     // Constructors with C++ primitive types, enums or pointers only.
     // Start with the ones with fewer arguments.
diff --git a/generator/generator.h b/generator/generator.h
index c48f008..e399df8 100644
--- a/generator/generator.h
+++ b/generator/generator.h
@@ -359,8 +359,8 @@ protected:
     */
     virtual QString subDirectoryForPackage(QString packageName = QString()) const;
 
-    QList<const AbstractMetaType*> instantiatedContainers() const;
-    QList<const AbstractMetaType*> instantiatedSmartPointers() const;
+    QVector<const AbstractMetaType*> instantiatedContainers() const;
+    QVector<const AbstractMetaType*> instantiatedSmartPointers() const;
 
     static QString getSimplifiedContainerTypeName(const AbstractMetaType *type);
     void addInstantiatedContainersAndSmartPointers(const AbstractMetaType *type,
diff --git a/generator/shiboken2/cppgenerator.cpp b/generator/shiboken2/cppgenerator.cpp
index aeee881..85829ab 100644
--- a/generator/shiboken2/cppgenerator.cpp
+++ b/generator/shiboken2/cppgenerator.cpp
@@ -154,11 +154,12 @@ QString CppGenerator::fileNameForContext(GeneratorContext &context) const
     }
 }
 
-QList<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
+QVector<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
                                                                              uint queryIn)
 {
     // ( func_name, num_args ) => func_list
-    QMap<QPair<QString, int >, AbstractMetaFunctionList> results;
+    typedef QMap<QPair<QString, int >, AbstractMetaFunctionList> ResultMap;
+    ResultMap results;
     const AbstractMetaClass::OperatorQueryOptions query(queryIn);
     const AbstractMetaFunctionList &funcs = metaClass->operatorOverloads(query);
     for (AbstractMetaFunction *func : funcs) {
@@ -178,7 +179,11 @@ QList<AbstractMetaFunctionList> CppGenerator::filterGroupedOperatorFunctions(con
         QPair<QString, int > op(func->name(), args);
         results[op].append(func);
     }
-    return results.values();
+    QVector<AbstractMetaFunctionList> result;
+    result.reserve(results.size());
+    for (ResultMap::const_iterator it = results.cbegin(), end = results.cend(); it != end; ++it)
+        result.append(it.value());
+    return result;
 }
 
 bool CppGenerator::hasBoolCast(const AbstractMetaClass* metaClass) const
@@ -479,7 +484,7 @@ void CppGenerator::generateClass(QTextStream &s, GeneratorContext &classContext)
     }
 
     if (supportsNumberProtocol(metaClass) && !metaClass->typeEntry()->isSmartPointer()) {
-        const QList<AbstractMetaFunctionList> opOverloads = filterGroupedOperatorFunctions(
+        const QVector<AbstractMetaFunctionList> opOverloads = filterGroupedOperatorFunctions(
                 metaClass,
                 AbstractMetaClass::ArithmeticOp
                 | AbstractMetaClass::LogicalOp
@@ -1519,7 +1524,7 @@ void CppGenerator::writeConstructorWrapper(QTextStream &s, const AbstractMetaFun
     QSet<QString> argNamesSet;
     if (usePySideExtensions() && metaClass->isQObject()) {
         // Write argNames variable with all known argument names.
-        const QList<const AbstractMetaFunction *> &overloads = overloadData.overloads();
+        const OverloadData::MetaFunctionList &overloads = overloadData.overloads();
         for (const AbstractMetaFunction *func : overloads) {
             const AbstractMetaArgumentList &arguments = func->arguments();
             for (const AbstractMetaArgument *arg : arguments) {
@@ -1819,7 +1824,7 @@ void CppGenerator::writeArgumentsInitializer(QTextStream& s, OverloadData& overl
             s << INDENT << '}';
         }
     }
-    QList<int> invalidArgsLength = overloadData.invalidArgumentLengths();
+    const QVector<int> invalidArgsLength = overloadData.invalidArgumentLengths();
     if (!invalidArgsLength.isEmpty()) {
         QStringList invArgsLen;
         for (int i : qAsConst(invalidArgsLength))
@@ -1950,7 +1955,7 @@ void CppGenerator::writeErrorSection(QTextStream& s, OverloadData& overloadData)
         s << INDENT << "Shiboken::setErrorAboutWrongArguments(" << argsVar << ", \"" << funcName << "\", 0);" << endl;
     } else {
         QStringList overloadSignatures;
-        const QList<const AbstractMetaFunction *> &overloads = overloadData.overloads();
+        const OverloadData::MetaFunctionList &overloads = overloadData.overloads();
         for (const AbstractMetaFunction *f : overloads) {
             QStringList args;
             const AbstractMetaArgumentList &arguments = f->arguments();
@@ -2131,7 +2136,7 @@ void CppGenerator::writeTypeCheck(QTextStream& s, const OverloadData* overloadDa
     QSet<const TypeEntry*> numericTypes;
     const OverloadDataList &overloads = overloadData->previousOverloadData()->nextOverloadData();
     for (OverloadData *od : overloads) {
-        const QList<const AbstractMetaFunction *> &odOverloads = od->overloads();
+        const OverloadData::MetaFunctionList &odOverloads = od->overloads();
         for (const AbstractMetaFunction *func : odOverloads) {
             checkTypeViability(func);
             const AbstractMetaType* argType = od->argument(func)->type();
@@ -2334,7 +2339,7 @@ void CppGenerator::writeOverloadedFunctionDecisor(QTextStream& s, const Overload
 {
     s << INDENT << "// Overloaded function decisor" << endl;
     const AbstractMetaFunction* rfunc = overloadData.referenceFunction();
-    QList<const AbstractMetaFunction*> functionOverloads = overloadData.overloadsWithoutRepetition();
+    const OverloadData::MetaFunctionList &functionOverloads = overloadData.overloadsWithoutRepetition();
     for (int i = 0; i < functionOverloads.count(); i++)
         s << INDENT << "// " << i << ": " << functionOverloads.at(i)->minimalSignature() << endl;
     writeOverloadedFunctionDecisorEngine(s, &overloadData);
@@ -2368,7 +2373,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
     // variable to be used further on this method on the conditional that identifies default
     // method calls.
     if (!hasDefaultCall) {
-        const QList<const AbstractMetaFunction *> &overloads = parentOverloadData->overloads();
+        const OverloadData::MetaFunctionList &overloads = parentOverloadData->overloads();
         for (const AbstractMetaFunction *func : overloads) {
             if (parentOverloadData->isFinalOccurrence(func)) {
                 referenceFunction = func;
@@ -2520,7 +2525,7 @@ void CppGenerator::writeOverloadedFunctionDecisorEngine(QTextStream& s, const Ov
 void CppGenerator::writeFunctionCalls(QTextStream &s, const OverloadData &overloadData,
                                       GeneratorContext &context)
 {
-    QList<const AbstractMetaFunction*> overloads = overloadData.overloadsWithoutRepetition();
+    const OverloadData::MetaFunctionList &overloads = overloadData.overloadsWithoutRepetition();
     s << INDENT << "// Call function/method" << endl;
     s << INDENT << (overloads.count() > 1 ? "switch (overloadId) " : "") << '{' << endl;
     {
@@ -3266,9 +3271,9 @@ void CppGenerator::writeMethodCall(QTextStream &s, const AbstractMetaFunction *f
     bool hasReturnPolicy = false;
 
     // Ownership transference between C++ and Python.
-    QList<ArgumentModification> ownership_mods;
+    QVector<ArgumentModification> ownership_mods;
     // Python object reference management.
-    QList<ArgumentModification> refcount_mods;
+    QVector<ArgumentModification> refcount_mods;
     const FunctionModificationList &funcMods = func->modifications();
     for (const FunctionModification &func_mod : funcMods) {
         for (const ArgumentModification &arg_mod : func_mod.argument_mods) {
@@ -3542,7 +3547,8 @@ void CppGenerator::writeContainerConverterInitialization(QTextStream& s, const A
     writeAddPythonToCppConversion(s, converterObject(type), toCpp, isConv);
 }
 
-void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QList<const AbstractMetaClass*>& conversions)
+void CppGenerator::writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType,
+                                                        const QVector<const AbstractMetaClass*>& conversions)
 {
     s << INDENT << "// Extended implicit conversions for " << externalType->qualifiedTargetLangName() << '.' << endl;
     for (const AbstractMetaClass *sourceClass : conversions) {
@@ -3939,7 +3945,7 @@ void CppGenerator::writeTypeAsNumberDefinition(QTextStream& s, const AbstractMet
     nb.insert(QLatin1String("__ixor__"), QString());
     nb.insert(QLatin1String("__ior__"), QString());
 
-    const QList<AbstractMetaFunctionList> opOverloads =
+    const QVector<AbstractMetaFunctionList> opOverloads =
             filterGroupedOperatorFunctions(metaClass,
                                            AbstractMetaClass::ArithmeticOp
                                            | AbstractMetaClass::LogicalOp
@@ -4183,7 +4189,7 @@ void CppGenerator::writeRichCompareFunction(QTextStream &s, GeneratorContext &co
     s << INDENT << "switch (op) {" << endl;
     {
         Indentation indent(INDENT);
-        const QList<AbstractMetaFunctionList> &groupedFuncs = filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp);
+        const QVector<AbstractMetaFunctionList> &groupedFuncs = filterGroupedOperatorFunctions(metaClass, AbstractMetaClass::ComparisonOp);
         for (const AbstractMetaFunctionList &overloads : groupedFuncs) {
             const AbstractMetaFunction* rfunc = overloads[0];
 
@@ -5154,7 +5160,7 @@ bool CppGenerator::finishGeneration()
     }
 
     // Initialize smart pointer types.
-    const QList<const AbstractMetaType *> &smartPtrs = instantiatedSmartPointers();
+    const QVector<const AbstractMetaType *> &smartPtrs = instantiatedSmartPointers();
     for (const AbstractMetaType *metaType : smartPtrs) {
         GeneratorContext context(0, metaType, true);
         QString initFunctionName = getInitFunctionName(context);
@@ -5310,7 +5316,7 @@ bool CppGenerator::finishGeneration()
         }
     }
 
-    const QList<const CustomConversion *> &typeConversions = getPrimitiveCustomConversions();
+    const QVector<const CustomConversion *> &typeConversions = getPrimitiveCustomConversions();
     if (!typeConversions.isEmpty()) {
         s << endl << "// Primitive Type converters." << endl << endl;
         for (const CustomConversion *conversion : typeConversions) {
@@ -5321,7 +5327,7 @@ bool CppGenerator::finishGeneration()
         s << endl;
     }
 
-    const QList<const AbstractMetaType *> &containers = instantiatedContainers();
+    const QVector<const AbstractMetaType *> &containers = instantiatedContainers();
     if (!containers.isEmpty()) {
         s << "// Container Type converters." << endl << endl;
         for (const AbstractMetaType *container : containers) {
diff --git a/generator/shiboken2/cppgenerator.h b/generator/shiboken2/cppgenerator.h
index c46d5f8..c3ca483 100644
--- a/generator/shiboken2/cppgenerator.h
+++ b/generator/shiboken2/cppgenerator.h
@@ -41,8 +41,8 @@ public:
 protected:
     QString fileNamePrefix() const override;
     QString fileNameForContext(GeneratorContext &context) const override;
-    QList<AbstractMetaFunctionList> filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
-                                                                   uint query);
+    QVector<AbstractMetaFunctionList> filterGroupedOperatorFunctions(const AbstractMetaClass* metaClass,
+                                                                     uint query);
     void generateClass(QTextStream& s, GeneratorContext &classContext) override;
     bool finishGeneration() override;
 
@@ -290,7 +290,7 @@ private:
     void writeEnumConverterInitialization(QTextStream& s, const TypeEntry* enumType);
     void writeEnumConverterInitialization(QTextStream& s, const AbstractMetaEnum* metaEnum);
     void writeContainerConverterInitialization(QTextStream& s, const AbstractMetaType* type);
-    void writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QList<const AbstractMetaClass*>& conversions);
+    void writeExtendedConverterInitialization(QTextStream& s, const TypeEntry* externalType, const QVector<const AbstractMetaClass*>& conversions);
 
     void writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, bool userHeuristicForReturn);
     bool writeParentChildManagement(QTextStream& s, const AbstractMetaFunction* func, int argIndex, bool userHeuristicPolicy);
diff --git a/generator/shiboken2/headergenerator.cpp b/generator/shiboken2/headergenerator.cpp
index 9f33a45..5a6d58a 100644
--- a/generator/shiboken2/headergenerator.cpp
+++ b/generator/shiboken2/headergenerator.cpp
@@ -327,7 +327,7 @@ bool HeaderGenerator::finishGeneration()
     // Write the smart pointer define indexes.
     int smartPointerCountIndex = getMaxTypeIndex();
     int smartPointerCount = 0;
-    const QList<const AbstractMetaType *> &instantiatedSmartPtrs = instantiatedSmartPointers();
+    const QVector<const AbstractMetaType *> &instantiatedSmartPtrs = instantiatedSmartPointers();
     for (const AbstractMetaType *metaType : instantiatedSmartPtrs) {
         QString variableName = getTypeIndexVariableName(metaType);
         macrosStream << "#define ";
@@ -367,7 +367,7 @@ bool HeaderGenerator::finishGeneration()
         _writeTypeIndexDefineLine(macrosStream, getTypeIndexVariableName(ptype), pCount++);
     }
 
-    const QList<const AbstractMetaType *> &containers = instantiatedContainers();
+    const QVector<const AbstractMetaType *> &containers = instantiatedContainers();
     for (const AbstractMetaType *container : containers) {
         //_writeTypeIndexDefineLine(macrosStream, getTypeIndexVariableName(container), pCount);
         // DEBUG
diff --git a/generator/shiboken2/overloaddata.cpp b/generator/shiboken2/overloaddata.cpp
index d94e1df..876185c 100644
--- a/generator/shiboken2/overloaddata.cpp
+++ b/generator/shiboken2/overloaddata.cpp
@@ -155,7 +155,7 @@ static QString getImplicitConversionTypeName(const AbstractMetaType* containerTy
 }
 
 static QString msgCyclicDependency(const QString &funcName, const QString &graphName,
-                                   const QList<const AbstractMetaFunction *> &involvedConversions)
+                                   const OverloadData::MetaFunctionList &involvedConversions)
 {
     QString result;
     QTextStream str(&result);
@@ -291,7 +291,7 @@ void OverloadData::sortNextOverloads()
 
     QStringList classesWithIntegerImplicitConversion;
 
-    QList<const AbstractMetaFunction *> involvedConversions;
+    MetaFunctionList involvedConversions;
 
     for (OverloadData *ov : m_nextOverloadData) {
         const AbstractMetaType* targetType = ov->argType();
@@ -731,9 +731,9 @@ bool OverloadData::isFinalOccurrence(const AbstractMetaFunction* func) const
     return true;
 }
 
-QList<const AbstractMetaFunction*> OverloadData::overloadsWithoutRepetition() const
+OverloadData::MetaFunctionList OverloadData::overloadsWithoutRepetition() const
 {
-    QList<const AbstractMetaFunction*> overloads = m_overloads;
+    MetaFunctionList overloads = m_overloads;
     for (const AbstractMetaFunction *func : m_overloads) {
         if (func->minimalSignature().endsWith(QLatin1String("const")))
             continue;
@@ -761,7 +761,7 @@ const AbstractMetaFunction* OverloadData::getFunctionWithDefaultValue() const
     return 0;
 }
 
-QList<int> OverloadData::invalidArgumentLengths() const
+QVector<int> OverloadData::invalidArgumentLengths() const
 {
     QSet<int> validArgLengths;
 
@@ -779,7 +779,7 @@ QList<int> OverloadData::invalidArgumentLengths() const
         validArgLengths << args.size() - offset;
     }
 
-    QList<int> invalidArgLengths;
+    QVector<int> invalidArgLengths;
     for (int i = minArgs() + 1; i < maxArgs(); i++) {
         if (!validArgLengths.contains(i))
             invalidArgLengths.append(i);
diff --git a/generator/shiboken2/overloaddata.h b/generator/shiboken2/overloaddata.h
index 959b96d..2d815f6 100644
--- a/generator/shiboken2/overloaddata.h
+++ b/generator/shiboken2/overloaddata.h
@@ -30,19 +30,21 @@
 #define OVERLOADDATA_H
 
 #include <abstractmetalang_typedefs.h>
-#include <QtCore/QList>
 #include <QtCore/QBitArray>
+#include <QtCore/QVector>
 
 QT_FORWARD_DECLARE_CLASS(QDebug)
 
 class ShibokenGenerator;
 
 class OverloadData;
-typedef QList<OverloadData*> OverloadDataList;
+typedef QVector<OverloadData *> OverloadDataList;
 
 class OverloadData
 {
 public:
+    typedef QVector<const AbstractMetaFunction *> MetaFunctionList;
+
     OverloadData(const AbstractMetaFunctionList& overloads, const ShibokenGenerator* generator);
     ~OverloadData();
 
@@ -100,12 +102,12 @@ public:
     bool isFinalOccurrence(const AbstractMetaFunction* func) const;
 
     /// Returns the list of overloads removing repeated constant functions (ex.: "foo()" and "foo()const", the second is removed).
-    QList<const AbstractMetaFunction*> overloadsWithoutRepetition() const;
-    const QList<const AbstractMetaFunction*>& overloads() const { return m_overloads; }
+    MetaFunctionList overloadsWithoutRepetition() const;
+    const MetaFunctionList& overloads() const { return m_overloads; }
     OverloadDataList nextOverloadData() const { return m_nextOverloadData; }
     OverloadData* previousOverloadData() const { return m_previousOverloadData; }
 
-    QList<int> invalidArgumentLengths() const;
+    QVector<int> invalidArgumentLengths() const;
 
     static int numberOfRemovedArguments(const AbstractMetaFunction* func, int finalArgPos = -1);
     static QPair<int, int> getMinMaxArguments(const AbstractMetaFunctionList& overloads);
@@ -146,7 +148,7 @@ private:
     int m_argPos;
     const AbstractMetaType* m_argType;
     QString m_argTypeReplaced;
-    QList<const AbstractMetaFunction*> m_overloads;
+    MetaFunctionList m_overloads;
 
     OverloadData* m_headOverloadData;
     OverloadDataList m_nextOverloadData;
diff --git a/generator/shiboken2/shibokengenerator.cpp b/generator/shiboken2/shibokengenerator.cpp
index b601e14..1437e17 100644
--- a/generator/shiboken2/shibokengenerator.cpp
+++ b/generator/shiboken2/shibokengenerator.cpp
@@ -1494,9 +1494,9 @@ ShibokenGenerator::ExtendedConverterData ShibokenGenerator::getExtendedConverter
     return extConvs;
 }
 
-QList<const CustomConversion*> ShibokenGenerator::getPrimitiveCustomConversions()
+QVector<const CustomConversion *> ShibokenGenerator::getPrimitiveCustomConversions()
 {
-    QList<const CustomConversion*> conversions;
+    QVector<const CustomConversion*> conversions;
     const PrimitiveTypeEntryList &primitiveTypeList = primitiveTypes();
     for (const PrimitiveTypeEntry *type : primitiveTypeList) {
         if (!shouldGenerateTypeEntry(type) || !isUserPrimitive(type) || !type->customConversion())
@@ -1921,7 +1921,7 @@ static QString getConverterTypeSystemVariableArgument(const QString& code, int p
 typedef QPair<QString, QString> StringPair;
 void ShibokenGenerator::replaceConverterTypeSystemVariable(TypeSystemConverterVariable converterVariable, QString& code)
 {
-    QList<StringPair> replacements;
+    QVector<StringPair> replacements;
     QRegularExpressionMatchIterator rit = m_typeSystemConvRegEx[converterVariable].globalMatch(code);
     while (rit.hasNext()) {
         const QRegularExpressionMatch match = rit.next();
diff --git a/generator/shiboken2/shibokengenerator.h b/generator/shiboken2/shibokengenerator.h
index 228df23..649d384 100644
--- a/generator/shiboken2/shibokengenerator.h
+++ b/generator/shiboken2/shibokengenerator.h
@@ -135,7 +135,7 @@ public:
 
     /// Utility function for writeCodeSnips.
     typedef QPair<const AbstractMetaArgument*, QString> ArgumentVarReplacementPair;
-    typedef QList<ArgumentVarReplacementPair> ArgumentVarReplacementList;
+    typedef QVector<ArgumentVarReplacementPair> ArgumentVarReplacementList;
     ArgumentVarReplacementList getArgumentReplacement(const AbstractMetaFunction* func,
                                                       bool usePyArgs, TypeSystem::Language language,
                                                       const AbstractMetaArgument* lastArg);
@@ -499,12 +499,12 @@ protected:
 
     // All data about extended converters: the type entries of the target type, and a
     // list of AbstractMetaClasses accepted as argument for the conversion.
-    typedef QHash<const TypeEntry*, QList<const AbstractMetaClass*> > ExtendedConverterData;
+    typedef QHash<const TypeEntry *, QVector<const AbstractMetaClass *> > ExtendedConverterData;
     /// Returns all extended conversions for the current module.
     ExtendedConverterData getExtendedConverters() const;
 
     /// Returns a list of converters for the non wrapper types of the current module.
-    QList<const CustomConversion*> getPrimitiveCustomConversions();
+    QVector<const CustomConversion *> getPrimitiveCustomConversions();
 
     /// Returns true if the Python wrapper for the received OverloadData must accept a list of arguments.
     static bool pythonFunctionWrapperUsesListOfArguments(const OverloadData& overloadData);