Fix QMetaType/QVariant-related deprecations

- Refactor code to use ints for metatype id

Change-Id: I0a88f19ade25b1f8bb5a5138c602a71cf1f7282a
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

5 files changed, 74 insertions, 74 deletions

diff --git a/src/activeqt/container/qaxbase.cpp b/src/activeqt/container/qaxbase.cpp
index 3ad5e1c..e09d737 100644
--- a/src/activeqt/container/qaxbase.cpp
+++ b/src/activeqt/container/qaxbase.cpp
@@ -3412,11 +3412,11 @@ int QAxBase::internalInvoke(QMetaObject::Call call, int index, void **v)
     int p;
     for (p = 0; p < int(params.cArgs); ++p) {
         bool out;
-        QByteArray type = moExtra.paramType(signature, p, &out);
-        QVariant::Type vt = QVariant::nameToType(type);
+        const QByteArray type = moExtra.paramType(signature, p, &out);
+        const QMetaType metaType = QMetaType::fromName(type);
         QVariant qvar;
-        if (vt != QVariant::UserType && vt != int(QMetaType::QVariant))
-            qvar = QVariant(QMetaType(int(vt)), v[p + 1]);
+        if (metaType.id() != QMetaType::User && metaType.id() != QMetaType::QVariant)
+            qvar = QVariant(metaType, v[p + 1]);
 
         if (!qvar.isValid()) {
             if (type == "IDispatch*") {
@@ -3431,7 +3431,7 @@ int QAxBase::internalInvoke(QMetaObject::Call call, int index, void **v)
             } else if (mo->indexOfEnumerator(type) != -1) {
                 qvar = *reinterpret_cast<const int *>(v[p + 1]);
             } else {
-                qvar = QVariant(QMetaType(QMetaType::type(type)), v[p + 1]);
+                qvar = QVariant(metaType, v[p + 1]);
             }
         }
 
@@ -3983,7 +3983,7 @@ QAxObject *QAxBase::querySubObject(const char *name, QList<QVariant> &vars)
         if (res.pdispVal) {
             if (rettype.isEmpty() || rettype == "IDispatch*" || rettype == "QVariant") {
                 object = new QAxObject(res.pdispVal, qObject());
-            } else if (QMetaType::type(rettype)) {
+            } else if (QMetaType::fromName(rettype).id() != QMetaType::UnknownType) {
                 QVariant qvar = VARIANTToQVariant(res, rettype, 0);
                 object = *static_cast<QAxObject**>(qvar.data());
 //                qVariantGet(qvar, object, rettype);
@@ -3997,7 +3997,7 @@ QAxObject *QAxBase::querySubObject(const char *name, QList<QVariant> &vars)
         if (res.punkVal) {
             if (rettype.isEmpty() || rettype == "IUnknown*") {
                 object = new QAxObject(res.punkVal, qObject());
-            } else if (QMetaType::type(rettype)) {
+            } else if (QMetaType::fromName(rettype).id() != QMetaType::UnknownType) {
                 QVariant qvar = VARIANTToQVariant(res, rettype, 0);
                 object = *static_cast<QAxObject**>(qvar.data());
 //                qVariantGet(qvar, object, rettype);
@@ -4240,10 +4240,10 @@ QVariant QAxBase::asVariant() const
         cn.remove(0, cn.lastIndexOf(':') + 1);
         cn += '*';
         QObject *object = qObject();
-        int typeId = QMetaType::type(cn);
-        if (typeId == QMetaType::UnknownType)
-            typeId = qRegisterMetaType<QObject *>(cn);
-        qvar = QVariant(QMetaType(typeId), &object);
+        QMetaType metaType = QMetaType::fromName(cn);
+        if (metaType.id() == QMetaType::UnknownType)
+            metaType = QMetaType(qRegisterMetaType<QObject *>(cn));
+        qvar = QVariant(metaType, &object);
     }
 
     return qvar;
@@ -4256,7 +4256,7 @@ void *qax_createObjectWrapper(int metaType, IUnknown *iface)
     if (!iface)
         return nullptr;
 
-    void *object = QMetaType::create(metaType, nullptr);
+    void *object = QMetaType(metaType).create(nullptr);
     QAxBasePrivate *d = reinterpret_cast<const QAxObject *>(object)->d;
 
     d->ptr = iface;
diff --git a/src/activeqt/container/qaxdump.cpp b/src/activeqt/container/qaxdump.cpp
index e941adb..093fef6 100644
--- a/src/activeqt/container/qaxdump.cpp
+++ b/src/activeqt/container/qaxdump.cpp
@@ -120,10 +120,8 @@ static QByteArray namedPrototype(const QByteArrayList &parameterTypes, const QBy
 
 static QByteArray toType(const QByteArray &t)
 {
-    QByteArray type = t;
-    int vartype = QVariant::nameToType(type);
-    if (vartype == QVariant::Invalid)
-        type = "int";
+    QByteArray type = QMetaType::fromName(type).id() != QMetaType::UnknownType
+        ? t : QByteArrayLiteral("int");
 
     if (type.at(0) == 'Q')
         type.remove(0, 1);
@@ -326,14 +324,14 @@ QString qax_generateDocumentation(QAxBase *that)
                              QLatin1String(type.constData()) +
                              QLatin1Char(' ') + QLatin1String(name.constData()) + QLatin1String("</h3>\n");
             detail += docuFromName(typeInfo, QString::fromLatin1(name));
-            QVariant::Type vartype = QVariant::nameToType(type);
             if (!prop.isReadable())
                 continue;
 
-            if (prop.isEnumType())
-                vartype = QVariant::Int;
+            const int vartype = prop.isEnumType()
+                ? int(QMetaType::Int)
+                : QMetaType::fromName(type).id();
 
-            if (vartype != QVariant::Invalid) {
+            if (vartype != QMetaType::UnknownType) {
                 detail += QLatin1String("<p>Read this property's value using QObject::property:<pre>\n");
                 if (prop.isEnumType())
                     detail += QLatin1String("\tint val = ");
diff --git a/src/activeqt/control/qaxserver.cpp b/src/activeqt/control/qaxserver.cpp
index c456df7..afc8413 100644
--- a/src/activeqt/control/qaxserver.cpp
+++ b/src/activeqt/control/qaxserver.cpp
@@ -106,7 +106,7 @@ QAxFactory *qAxFactory()
         QStringList keys(qax_factory->featureList());
         for (int i = 0; i < keys.count(); ++i) {
             QByteArray pointerType = keys.at(i).toLatin1() + '*';
-            if (!QMetaType::type(pointerType.constData()))
+            if (QMetaType::fromName(pointerType).id() == QMetaType::UnknownType)
                 qRegisterMetaType<void *>(pointerType);
         }
     }
@@ -1259,11 +1259,11 @@ extern "C" HRESULT __stdcall DumpIDL(const QString &outfile, const QString &ver)
             QByteArray cleanType = qax_clean_type(className, mo).toLatin1();
             out << "\tcoclass " << cleanType << ';' << Qt::endl;
             subtypes.append(cleanType);
-            if (!QMetaType::type(cleanType))
+            if (QMetaType::fromName(cleanType).id() == QMetaType::UnknownType)
                 qRegisterMetaType<void *>(cleanType);
             cleanType += '*';
             subtypes.append(cleanType);
-            if (!QMetaType::type(cleanType))
+            if (QMetaType::fromName(cleanType).id() == QMetaType::UnknownType)
                 qRegisterMetaType<void *>(cleanType);
         }
     }
diff --git a/src/activeqt/control/qaxserverbase.cpp b/src/activeqt/control/qaxserverbase.cpp
index cbd4cd1..bf146c2 100644
--- a/src/activeqt/control/qaxserverbase.cpp
+++ b/src/activeqt/control/qaxserverbase.cpp
@@ -2061,17 +2061,15 @@ int QAxServerBase::qt_metacall(QMetaObject::Call call, int index, void **argv)
                         // convert enum values to int
                         variant = QVariant(*reinterpret_cast<int *>(argv[p+1]));
                     } else {
-                        QVariant::Type vt = QVariant::nameToType(ptype);
-                        if (vt == QVariant::UserType) {
+                        const QMetaType metaType = QMetaType::fromName(ptype);
+                        if (metaType.id() == QMetaType::User) {
                             if (ptype.endsWith('*')) {
-                                variant = QVariant(QMetaType(QMetaType::type(ptype)), reinterpret_cast<void **>(argv[p+1]));
-                                // variant.setValue(*(void**)(argv[p + 1]), ptype);
+                                variant = QVariant(metaType, reinterpret_cast<void **>(argv[p+1]));
                             } else {
-                                variant = QVariant(QMetaType(QMetaType::type(ptype)), argv[p+1]);
-                                // variant.setValue(argv[p + 1], ptype);
+                                variant = QVariant(metaType, argv[p+1]);
                             }
                         } else {
-                            variant = QVariant(QMetaType(int(vt)), argv[p + 1]);
+                            variant = QVariant(metaType, argv[p + 1]);
                         }
                     }
 
@@ -2515,15 +2513,15 @@ HRESULT WINAPI QAxServerBase::Invoke(DISPID dispidMember, REFIID riid,
 
             // return value
             if (!type.isEmpty() && type != "void") {
-                QVariant::Type vt = QVariant::nameToType(type);
-                if (vt == int(QMetaType::QVariant)) {
+                int vt = QMetaType::fromName(type).id();
+                if (vt == QMetaType::QVariant) {
                     argv[0] = varp;
                 } else {
-                    if (vt == QVariant::UserType)
-                        vt = QVariant::Invalid;
-                    else if (vt == QVariant::Invalid && mo->indexOfEnumerator(slot.typeName()) != -1)
-                        vt = QVariant::Int;
-                    varp[0] = QVariant(vt);
+                    if (vt == QMetaType::User)
+                        vt = QMetaType::UnknownType;
+                    else if (vt == QMetaType::UnknownType && mo->indexOfEnumerator(slot.typeName()) != -1)
+                        vt = QMetaType::Int;
+                    varp[0] = QVariant(QMetaType(vt));
                     if (varp[0].type() == QVariant::Invalid)
                         argv[0] = nullptr;
                     else
@@ -2553,7 +2551,7 @@ HRESULT WINAPI QAxServerBase::Invoke(DISPID dispidMember, REFIID riid,
                 }
                 if (!type.isEmpty() && type != "void" && pvarResult) {
                     if (!varp[0].isValid() && type != "QVariant")
-                        varp[0] = QVariant(QMetaType(QMetaType::type(type)), argv_pointer);
+                        varp[0] = QVariant(QMetaType::fromName(type), argv_pointer);
 //                        varp[0].setValue(argv_pointer[0], type);
                     ok = QVariantToVARIANT(varp[0], *pvarResult, type);
                 }
diff --git a/src/activeqt/shared/qaxtypes.cpp b/src/activeqt/shared/qaxtypes.cpp
index 501bf51..03efbba 100644
--- a/src/activeqt/shared/qaxtypes.cpp
+++ b/src/activeqt/shared/qaxtypes.cpp
@@ -267,22 +267,25 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
 {
     QVariant qvar = var;
     // "type" is the expected type, so coerce if necessary
-    const QVariant::Type proptype = typeName.isEmpty() ? QVariant::Invalid : QVariant::nameToType(typeName);
-    if (proptype != QVariant::Invalid
-        && proptype != QVariant::UserType
-        && proptype != int(QMetaType::QVariant)
+    const int proptype = typeName.isEmpty()
+        ? QMetaType::UnknownType
+        : QMetaType::fromName(typeName).id();
+    if (proptype != QMetaType::UnknownType
+        && proptype != QMetaType::User
+        && proptype != QMetaType::QVariant
         && proptype != qvar.type()) {
-        if (qvar.canConvert(proptype))
-            qvar.convert(proptype);
+        const QMetaType metaType(proptype);
+        if (qvar.canConvert(metaType))
+            qvar.convert(metaType);
         else
-            qvar = QVariant(proptype);
+            qvar = QVariant(metaType);
     }
 
     if (out && arg.vt == (VT_VARIANT|VT_BYREF) && arg.pvarVal) {
         return QVariantToVARIANT(var, *arg.pvarVal, typeName, false);
     }
 
-    if (out && proptype == QVariant::UserType && typeName == "QVariant") {
+    if (out && proptype == QMetaType::User && typeName == "QVariant") {
         VARIANT *pVariant = new VARIANT;
         QVariantToVARIANT(var, *pVariant, QByteArray(), false);
         arg.vt = VT_VARIANT|VT_BYREF;
@@ -444,10 +447,10 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
             const auto list = qvar.toList();
             const int count = list.count();
             VARTYPE vt = VT_VARIANT;
-            QVariant::Type listType = QVariant::Type(QMetaType::QVariant);
+            int listType = QMetaType::QVariant;
             if (!typeName.isEmpty() && typeName.startsWith("QList<")) {
                 const QByteArray listTypeName = typeName.mid(6, typeName.length() - 7); // QList<int> -> int
-                listType = QVariant::nameToType(listTypeName);
+                listType = QMetaType::fromName(listTypeName).id();
             }
 
             VARIANT variant;
@@ -510,8 +513,8 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
                 array = SafeArrayCreateVector(vt, 0, count);
                 for (LONG index = 0; index < count; ++index) {
                     QVariant elem = list.at(index);
-                    if (listType != QVariant::Type(QMetaType::QVariant))
-                        elem.convert(listType);
+                    if (listType != QMetaType::QVariant)
+                        elem.convert(QMetaType(listType));
                     VariantInit(&variant);
                     QVariantToVARIANT(elem, variant, elem.typeName());
                     SafeArrayPutElement(array, &index, pElement);
@@ -704,7 +707,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
                     qAxFactory()->createObjectWrapper(static_cast<QObject*>(user), &arg.pdispVal);
                 }
 #else
-            } else if (QMetaType::type(subType)) {
+            } else if (QMetaType::fromName(subType).id() != QMetaType::UnknownType) {
                 if (out) {
                     qWarning().noquote() << msgOutParameterNotSupported("subtype");
                     arg.vt = VT_EMPTY;
@@ -895,17 +898,17 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
     case VT_DATE:
         var = DATEToQDateTime(arg.date);
         if (type == QVariant::Date || (!type && (typeName == "QDate" || typeName == "QDate*"))) {
-            var.convert(QVariant::Date);
+            var.convert(QMetaType(QMetaType::QDate));
         } else if (type == QVariant::Time || (!type && (typeName == "QTime" || typeName == "QTime*"))) {
-            var.convert(QVariant::Time);
+            var.convert(QMetaType(QMetaType::QTime));
         }
         break;
     case VT_DATE|VT_BYREF:
         var = DATEToQDateTime(*arg.pdate);
         if (type == QVariant::Date || (!type && (typeName == "QDate" || typeName == "QDate*"))) {
-            var.convert(QVariant::Date);
+            var.convert(QMetaType(QMetaType::QDate));
         } else if (type == QVariant::Time || (!type && (typeName == "QTime" || typeName == "QTime*"))) {
-            var.convert(QVariant::Time);
+            var.convert(QMetaType(QMetaType::QTime));
         }
         break;
     case VT_VARIANT:
@@ -952,10 +955,10 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
                     QObject *qObj = iface->qObject();
                     iface->Release();
                     QByteArray pointerType = qObj ? QByteArray(qObj->metaObject()->className()) + '*' : typeName;
-                    int pointerTypeId = QMetaType::type(pointerType);
-                    if (!pointerTypeId)
-                        pointerTypeId = qRegisterMetaType<QObject *>(pointerType);
-                    var = QVariant(QMetaType(pointerTypeId), &qObj);
+                    QMetaType pointerMetaType = QMetaType::fromName(pointerType);
+                    if (pointerMetaType.id() == QMetaType::UnknownType)
+                        pointerMetaType = QMetaType(qRegisterMetaType<QObject *>(pointerType));
+                    var = QVariant(pointerMetaType, &qObj);
                 } else
 #endif
                 {
@@ -968,15 +971,15 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
                             if (typeName == "QVariant") {
                                 QAxObject *object = new QAxObject(disp);
                                 var = QVariant::fromValue<QAxObject*>(object);
-                            } else if (typeName != "IDispatch*" && QMetaType::type(typeName)) {
+                            } else if (typeName != "IDispatch*" &&  QMetaType::fromName(typeName).id() != QMetaType::UnknownType) {
                                 QByteArray typeNameStr = QByteArray(typeName);
                                 int pIndex = typeName.lastIndexOf('*');
                                 if (pIndex != -1)
                                     typeNameStr = typeName.left(pIndex);
-                                int metaType = QMetaType::type(typeNameStr);
-                                Q_ASSERT(metaType != 0);
-                                auto object = static_cast<QAxObject*>(qax_createObjectWrapper(metaType, disp));
-                                var = QVariant(QMetaType(QMetaType::type(typeName)), &object);
+                                const QMetaType metaType = QMetaType::fromName(typeNameStr);
+                                Q_ASSERT(metaType.id() != QMetaType::UnknownType);
+                                auto object = static_cast<QAxObject*>(qax_createObjectWrapper(metaType.id(), disp));
+                                var = QVariant(metaType, &object);
                             } else {
 #endif
                                 static const int dispatchId = qRegisterMetaType<IDispatch*>(typeName.constData());
@@ -1224,22 +1227,23 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
         break;
     }
 
-    QVariant::Type proptype = (QVariant::Type)type;
-    if (proptype == QVariant::Invalid && !typeName.isEmpty()) {
-        if (typeName != "QVariant")
-            proptype = QVariant::nameToType(typeName);
-    }
-    if (proptype != QVariant::Type(QMetaType::QVariant) && proptype != QVariant::LastType && proptype != QVariant::Invalid && var.type() != proptype) {
-        if (var.canConvert(proptype)) {
+    const int proptype = type != QMetaType::UnknownType || typeName.isEmpty() || typeName == "QVariant"
+        ? int(type)
+        : QMetaType::fromName(typeName).id();
+
+    if (proptype != QMetaType::QVariant && proptype != QVariant::LastType
+        && QMetaType::UnknownType && var.type() != proptype) {
+        QMetaType propertyMetaType(proptype);
+        if (var.canConvert(propertyMetaType)) {
             QVariant oldvar = var;
-            if (oldvar.convert(proptype))
+            if (oldvar.convert(propertyMetaType))
                 var = oldvar;
-        } else if (proptype == QVariant::StringList && var.type() == QVariant::List) {
+        } else if (proptype == QMetaType::QStringList && var.type() == QVariant::List) {
             bool allStrings = true;
             QStringList strings;
             const QVariantList list(var.toList());
             for (const QVariant &variant : list) {
-                if (variant.canConvert(QVariant::String))
+                if (variant.canConvert(QMetaType(QMetaType::QString)))
                     strings << variant.toString();
                 else
                     allStrings = false;