Deprecate the static int based API in QMetaType

And remove one of the type id to name mapping that still
existed in QMetaType. QMetaTypeInterface can provide that,
so there's no need to have a second copy of the data.

qMetaTypeTypeInternal() can still map all the names of all
builtin types to ids. That functionality is for now still
required by moc and can't be removed yet.

Change-Id: Ib4f8e9c71e1e7d99d52da9e44477c9a1f1805e57
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

19 files changed, 147 insertions, 147 deletions

diff --git a/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp b/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
index 057f61e6c1..03c76aba5d 100644
--- a/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
+++ b/tests/auto/corelib/kernel/qmetamethod/tst_qmetamethod.cpp
@@ -629,7 +629,7 @@ void tst_QMetaMethod::method()
     QVERIFY(method.typeName() != 0);
     if (QByteArray(method.typeName()) != returnTypeName) {
         // QMetaMethod should always produce a semantically equivalent typename
-        QCOMPARE(QMetaType::type(method.typeName()), QMetaType::type(returnTypeName));
+        QCOMPARE(QMetaType::fromName(method.typeName()), QMetaType::fromName(returnTypeName));
     }
 
     if (method.parameterTypes() != parameterTypeNames) {
@@ -637,8 +637,8 @@ void tst_QMetaMethod::method()
         QList<QByteArray> actualTypeNames = method.parameterTypes();
         QCOMPARE(actualTypeNames.size(), parameterTypeNames.size());
         for (int i = 0; i < parameterTypeNames.size(); ++i) {
-            QCOMPARE(QMetaType::type(actualTypeNames.at(i)),
-                     QMetaType::type(parameterTypeNames.at(i)));
+            QCOMPARE(QMetaType::fromName(actualTypeNames.at(i)),
+                     QMetaType::fromName(parameterTypeNames.at(i)));
         }
     }
     QCOMPARE(method.parameterNames(), parameterNames);
diff --git a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
index 06e586322f..fde1255443 100644
--- a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
+++ b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
@@ -1452,7 +1452,7 @@ void tst_QMetaObject::customPropertyType()
     QCOMPARE(prop.metaType(), QMetaType::fromType<MyStruct>());
 
     qRegisterMetaType<MyStruct>("MyStruct");
-    QCOMPARE(prop.userType(), QMetaType::type("MyStruct"));
+    QCOMPARE(prop.userType(), QMetaType::fromName("MyStruct").id());
 
     prop = metaObject()->property(metaObject()->indexOfProperty("value4"));
     QCOMPARE(prop.type(), QVariant::List);
diff --git a/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp b/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp
index 9bce6a7a28..06bca28001 100644
--- a/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp
+++ b/tests/auto/corelib/kernel/qmetaproperty/tst_qmetaproperty.cpp
@@ -211,20 +211,20 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(EnumFlagsTester::TestFlags)
 
 void tst_QMetaProperty::readAndWriteWithLazyRegistration()
 {
-    QCOMPARE(QMetaType::type("CustomReadObject*"), int(QMetaType::UnknownType));
-    QCOMPARE(QMetaType::type("CustomWriteObject*"), int(QMetaType::UnknownType));
+    QVERIFY(!QMetaType::fromName("CustomReadObject*").isValid());
+    QVERIFY(!QMetaType::fromName("CustomWriteObject*").isValid());
 
     TypeLazyRegistration o;
     QVERIFY(o.property("read").isValid());
-    QVERIFY(QMetaType::type("CustomReadObject*") != QMetaType::UnknownType);
-    QCOMPARE(QMetaType::type("CustomWriteObject*"), int(QMetaType::UnknownType));
+    QVERIFY(QMetaType::fromName("CustomReadObject*").isValid());
+    QVERIFY(!QMetaType::fromName("CustomWriteObject*").isValid());
 
     CustomWriteObjectChild data;
     QVariant value = QVariant::fromValue(&data); // this register CustomWriteObjectChild
     // check if base classes are not registered automatically, otherwise this test would be meaningless
-    QCOMPARE(QMetaType::type("CustomWriteObject*"), int(QMetaType::UnknownType));
+    QVERIFY(!QMetaType::fromName("CustomWriteObject*").isValid());
     QVERIFY(o.setProperty("write", value));
-    QVERIFY(QMetaType::type("CustomWriteObject*") != QMetaType::UnknownType);
+    QVERIFY(QMetaType::fromName("CustomWriteObject*").isValid());
     QCOMPARE(o.property("write").value<CustomWriteObjectChild*>(), &data);
 }
 
diff --git a/tests/auto/corelib/kernel/qmetatype/.prev_CMakeLists.txt b/tests/auto/corelib/kernel/qmetatype/.prev_CMakeLists.txt
index a6a3bb58c1..16188d2d33 100644
--- a/tests/auto/corelib/kernel/qmetatype/.prev_CMakeLists.txt
+++ b/tests/auto/corelib/kernel/qmetatype/.prev_CMakeLists.txt
@@ -16,6 +16,7 @@ qt_add_test(tst_qmetatype
         ../../../other/qvariant_common
     PUBLIC_LIBRARIES
         Qt::CorePrivate
+        Qt::Gui
     TESTDATA ${test_data}
 )
 
diff --git a/tests/auto/corelib/kernel/qmetatype/CMakeLists.txt b/tests/auto/corelib/kernel/qmetatype/CMakeLists.txt
index a6a3bb58c1..16188d2d33 100644
--- a/tests/auto/corelib/kernel/qmetatype/CMakeLists.txt
+++ b/tests/auto/corelib/kernel/qmetatype/CMakeLists.txt
@@ -16,6 +16,7 @@ qt_add_test(tst_qmetatype
         ../../../other/qvariant_common
     PUBLIC_LIBRARIES
         Qt::CorePrivate
+        Qt::Gui
     TESTDATA ${test_data}
 )
 
diff --git a/tests/auto/corelib/kernel/qmetatype/qmetatype.pro b/tests/auto/corelib/kernel/qmetatype/qmetatype.pro
index ae36fb07f9..f9c08377dd 100644
--- a/tests/auto/corelib/kernel/qmetatype/qmetatype.pro
+++ b/tests/auto/corelib/kernel/qmetatype/qmetatype.pro
@@ -1,6 +1,6 @@
 CONFIG += testcase
 TARGET = tst_qmetatype
-QT = core-private testlib
+QT = core-private testlib gui
 INCLUDEPATH += $$PWD/../../../other/qvariant_common
 SOURCES = tst_qmetatype.cpp
 TESTDATA=./typeFlags.bin
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index caeb9f656f..49f9be0ce2 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -268,8 +268,8 @@ struct GenericGadgetType : BaseGenericType
         if (_c == QMetaObject::ReadProperty) {
             if (_id < properties.size()) {
                 const auto &prop = properties.at(_id);
-                QMetaType::destruct(int(prop.userType()), _a[0]);
-                QMetaType::construct(int(prop.userType()), _a[0], prop.constData());
+                prop.metaType().destruct(_a[0]);
+                prop.metaType().construct(_a[0], prop.constData());
             }
         } else if (_c == QMetaObject::WriteProperty) {
             if (_id < properties.size()) {
@@ -402,7 +402,7 @@ void tst_QMetaType::registerGadget(const char *name, const QList<GadgetPropertyT
     gadgetBuilder.setFlags(metaObjectflags);
     auto dynamicGadgetProperties = std::make_shared<GenericGadgetType>();
     for (const auto &prop : gadgetProperties) {
-        int propertyType = QMetaType::type(prop.type);
+        int propertyType = QMetaType::fromName(prop.type).id();
         dynamicGadgetProperties->properties.push_back(QVariant(QMetaType(propertyType)));
         auto dynamicPropery = gadgetBuilder.addProperty(prop.name, prop.type);
         dynamicPropery.setWritable(true);
@@ -715,6 +715,9 @@ void tst_QMetaType::typeName()
     QFETCH(int, aType);
     QFETCH(QString, aTypeName);
 
+    if (aType >= QMetaType::FirstWidgetsType)
+        QSKIP("The test doesn't link against QtWidgets.");
+
     const char *rawname = QMetaType::typeName(aType);
     QString name = QString::fromLatin1(rawname);
 
@@ -753,6 +756,8 @@ void tst_QMetaType::type()
     QFETCH(int, aType);
     QFETCH(QByteArray, aTypeName);
 
+    if (aType >= QMetaType::FirstWidgetsType)
+        QSKIP("The test doesn't link against QtWidgets.");
     // QMetaType::type(QByteArray)
     QCOMPARE(QMetaType::type(aTypeName), aType);
     // QMetaType::type(const char *)
@@ -1978,11 +1983,6 @@ DECLARE_NONSTREAMABLE(QPersistentModelIndex)
 DECLARE_NONSTREAMABLE(QObject*)
 DECLARE_NONSTREAMABLE(QWidget*)
 
-#define DECLARE_GUI_CLASS_NONSTREAMABLE(MetaTypeName, MetaTypeId, RealType) \
-    DECLARE_NONSTREAMABLE(RealType)
-QT_FOR_EACH_STATIC_GUI_CLASS(DECLARE_GUI_CLASS_NONSTREAMABLE)
-#undef DECLARE_GUI_CLASS_NONSTREAMABLE
-
 #define DECLARE_WIDGETS_CLASS_NONSTREAMABLE(MetaTypeName, MetaTypeId, RealType) \
     DECLARE_NONSTREAMABLE(RealType)
 QT_FOR_EACH_STATIC_WIDGETS_CLASS(DECLARE_WIDGETS_CLASS_NONSTREAMABLE)
diff --git a/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp b/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
index 9b32d3a797..90fadbb628 100644
--- a/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
+++ b/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
@@ -546,10 +546,9 @@ void tst_QEasingCurve::properties()
 
 void tst_QEasingCurve::metaTypes()
 {
-    QVERIFY(QMetaType::type("QEasingCurve") == QMetaType::QEasingCurve);
+    QVERIFY(QMetaType::fromName("QEasingCurve").id() == QMetaType::QEasingCurve);
 
-    QCOMPARE(QByteArray(QMetaType::typeName(QMetaType::QEasingCurve)),
-             QByteArray("QEasingCurve"));
+    QCOMPARE(QByteArray(QMetaType(QMetaType::QEasingCurve).name()), QByteArray("QEasingCurve"));
 
     QVERIFY(QMetaType::isRegistered(QMetaType::QEasingCurve));
 
diff --git a/tests/auto/corelib/tools/qlist/tst_qlist.cpp b/tests/auto/corelib/tools/qlist/tst_qlist.cpp
index f0af24a96b..56651ae474 100644
--- a/tests/auto/corelib/tools/qlist/tst_qlist.cpp
+++ b/tests/auto/corelib/tools/qlist/tst_qlist.cpp
@@ -1086,7 +1086,7 @@ void tst_QList::cpp17ctad() const
 #ifdef __cpp_deduction_guides
 #define QVERIFY_IS_VECTOR_OF(obj, Type) \
     QVERIFY2((std::is_same<decltype(obj), QList<Type>>::value), \
-             QMetaType::typeName(qMetaTypeId<decltype(obj)::value_type>()))
+             QMetaType::fromType<decltype(obj)::value_type>().name())
 #define CHECK(Type, One, Two, Three) \
     do { \
         const Type v[] = {One, Two, Three}; \
diff --git a/tests/auto/corelib/tools/qset/tst_qset.cpp b/tests/auto/corelib/tools/qset/tst_qset.cpp
index ee6cf7f533..72ad484842 100644
--- a/tests/auto/corelib/tools/qset/tst_qset.cpp
+++ b/tests/auto/corelib/tools/qset/tst_qset.cpp
@@ -331,7 +331,7 @@ void tst_QSet::cpp17ctad()
 #ifdef __cpp_deduction_guides
 #define QVERIFY_IS_SET_OF(obj, Type) \
     QVERIFY2((std::is_same<decltype(obj), QSet<Type>>::value), \
-             QMetaType::typeName(qMetaTypeId<decltype(obj)::value_type>()))
+             QMetaType::fromType<decltype(obj)::value_type>().name())
 #define CHECK(Type, One, Two, Three) \
     do { \
         const Type v[] = {One, Two, Three}; \
diff --git a/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp b/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
index 1ce5f1e0e6..3a504177db 100644
--- a/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
+++ b/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
@@ -785,7 +785,7 @@ void tst_QVarLengthArray::cpp17ctad()
 #ifdef __cpp_deduction_guides
 #define QVERIFY_IS_VLA_OF(obj, Type) \
     QVERIFY2((std::is_same<decltype(obj), QVarLengthArray<Type>>::value), \
-             QMetaType::typeName(qMetaTypeId<decltype(obj)::value_type>()))
+             QMetaType::fromType<decltype(obj)::value_type>().name())
 #define CHECK(Type, One, Two, Three) \
     do { \
         const Type v[] = {One, Two, Three}; \
diff --git a/tests/auto/dbus/qdbusmarshall/common.h b/tests/auto/dbus/qdbusmarshall/common.h
index 7a42e8f97f..6695567a80 100644
--- a/tests/auto/dbus/qdbusmarshall/common.h
+++ b/tests/auto/dbus/qdbusmarshall/common.h
@@ -522,7 +522,7 @@ bool compareToArgument(const QDBusArgument &arg, const QVariant &v2)
 
     qWarning() << "Unexpected QVariant type" << v2.userType()
                << QByteArray(QDBusMetaType::typeToSignature(v2.userType()))
-               << QMetaType::typeName(v2.userType());
+               << v2.metaType().name();
     return false;
 }
 
@@ -531,7 +531,7 @@ template<> bool compare(const QVariant &v1, const QVariant &v2)
     // v1 is the one that came from the network
     // v2 is the one that we sent
 
-    if (v1.userType() == qMetaTypeId<QDBusArgument>())
+    if (v1.metaType() == QMetaType::fromType<QDBusArgument>())
         // this argument has been left un-demarshalled
         return compareToArgument(qvariant_cast<QDBusArgument>(v1), v2);
 
diff --git a/tests/auto/gui/kernel/qguimetatype/tst_qguimetatype.cpp b/tests/auto/gui/kernel/qguimetatype/tst_qguimetatype.cpp
index c1ef8e2a60..670b271d54 100644
--- a/tests/auto/gui/kernel/qguimetatype/tst_qguimetatype.cpp
+++ b/tests/auto/gui/kernel/qguimetatype/tst_qguimetatype.cpp
@@ -219,7 +219,7 @@ void tst_QGuiMetaType::create_data()
 {
     QTest::addColumn<QMetaType::Type>("type");
 #define ADD_METATYPE_TEST_ROW(TYPE, ID) \
-    QTest::newRow(QMetaType::typeName(QMetaType::ID)) << QMetaType::ID;
+    QTest::newRow(QMetaType(QMetaType::ID).name()) << QMetaType::ID;
 FOR_EACH_GUI_METATYPE(ADD_METATYPE_TEST_ROW)
 #undef ADD_METATYPE_TEST_ROW
 }
@@ -228,11 +228,11 @@ template <int ID>
 static void testCreateHelper()
 {
     typedef typename MetaEnumToType<ID>::Type Type;
-    void *actual = QMetaType::create(ID);
+    void *actual = QMetaType(ID).create();
     Type *expected = DefaultValueFactory<ID>::create();
     QVERIFY(TypeComparator<ID>::equal(*static_cast<Type *>(actual), *expected));
     delete expected;
-    QMetaType::destroy(ID, actual);
+    QMetaType(ID).destroy(actual);
 }
 
 typedef void (*TypeTestFunction)();
@@ -268,9 +268,9 @@ static void testCreateCopyHelper()
 {
     typedef typename MetaEnumToType<ID>::Type Type;
     Type *expected = TestValueFactory<ID>::create();
-    void *actual = QMetaType::create(ID, expected);
+    void *actual = QMetaType(ID).create(expected);
     QVERIFY(TypeComparator<ID>::equal(*static_cast<Type*>(actual), *expected));
-    QMetaType::destroy(ID, actual);
+    QMetaType(ID).destroy(actual);
     delete expected;
 }
 
@@ -300,7 +300,7 @@ void tst_QGuiMetaType::sizeOf_data()
     QTest::addColumn<QMetaType::Type>("type");
     QTest::addColumn<int>("size");
 #define ADD_METATYPE_TEST_ROW(TYPE, ID) \
-    QTest::newRow(QMetaType::typeName(QMetaType::ID)) << QMetaType::ID << int(sizeof(TYPE));
+    QTest::newRow(QMetaType(QMetaType::ID).name()) << QMetaType::ID << int(sizeof(TYPE));
 FOR_EACH_GUI_METATYPE(ADD_METATYPE_TEST_ROW)
 #undef ADD_METATYPE_TEST_ROW
 }
@@ -309,7 +309,7 @@ void tst_QGuiMetaType::sizeOf()
 {
     QFETCH(QMetaType::Type, type);
     QFETCH(int, size);
-    QCOMPARE(QMetaType::sizeOf(type), size);
+    QCOMPARE(QMetaType(type).sizeOf(), size);
 }
 
 template<class T>
@@ -336,9 +336,9 @@ void tst_QGuiMetaType::flags()
     QFETCH(bool, isRelocatable);
     QFETCH(bool, isComplex);
 
-    QCOMPARE(bool(QMetaType::typeFlags(type) & QMetaType::NeedsConstruction), isComplex);
-    QCOMPARE(bool(QMetaType::typeFlags(type) & QMetaType::NeedsDestruction), isComplex);
-    QCOMPARE(bool(QMetaType::typeFlags(type) & QMetaType::MovableType), isRelocatable);
+    QCOMPARE(bool(QMetaType(type).flags() & QMetaType::NeedsConstruction), isComplex);
+    QCOMPARE(bool(QMetaType(type).flags() & QMetaType::NeedsDestruction), isComplex);
+    QCOMPARE(bool(QMetaType(type).flags() & QMetaType::MovableType), isRelocatable);
 }
 
 
@@ -351,14 +351,14 @@ template <int ID>
 static void testConstructHelper()
 {
     typedef typename MetaEnumToType<ID>::Type Type;
-    int size = QMetaType::sizeOf(ID);
+    int size = QMetaType(ID).sizeOf();
     void *storage = qMallocAligned(size, TypeAlignment<Type>::Value);
-    void *actual = QMetaType::construct(ID, storage, /*copy=*/0);
+    void *actual = QMetaType(ID).construct(storage, /*copy=*/0);
     QCOMPARE(actual, storage);
     Type *expected = DefaultValueFactory<ID>::create();
-    QVERIFY2(TypeComparator<ID>::equal(*static_cast<Type *>(actual), *expected), QMetaType::typeName(ID));
+    QVERIFY2(TypeComparator<ID>::equal(*static_cast<Type *>(actual), *expected), QMetaType(ID).name());
     delete expected;
-    QMetaType::destruct(ID, actual);
+    QMetaType(ID).destruct(actual);
     qFreeAligned(storage);
 }
 
@@ -393,12 +393,12 @@ static void testConstructCopyHelper()
 {
     typedef typename MetaEnumToType<ID>::Type Type;
     Type *expected = TestValueFactory<ID>::create();
-    int size = QMetaType::sizeOf(ID);
+    int size = QMetaType(ID).sizeOf();
     void *storage = qMallocAligned(size, TypeAlignment<Type>::Value);
-    void *actual = QMetaType::construct(ID, storage, expected);
+    void *actual = QMetaType(ID).construct(storage, expected);
     QCOMPARE(actual, storage);
-    QVERIFY2(TypeComparator<ID>::equal(*static_cast<Type*>(actual), *expected), QMetaType::typeName(ID));
-    QMetaType::destruct(ID, actual);
+    QVERIFY2(TypeComparator<ID>::equal(*static_cast<Type*>(actual), *expected), QMetaType(ID).name());
+    QMetaType(ID).destruct(actual);
     qFreeAligned(storage);
     delete expected;
 }
@@ -447,25 +447,25 @@ void tst_QGuiMetaType::saveAndLoadBuiltin()
     QFETCH(int, type);
     QFETCH(bool, isStreamable);
 
-    void *value = QMetaType::create(type);
+    void *value = QMetaType(type).create();
 
     QByteArray ba;
     QDataStream stream(&ba, QIODevice::ReadWrite);
-    QCOMPARE(QMetaType::save(stream, type, value), isStreamable);
+    QCOMPARE(QMetaType(type).save(stream, value), isStreamable);
     QCOMPARE(stream.status(), QDataStream::Ok);
 
     if (isStreamable)
-        QVERIFY(QMetaType::load(stream, type, value));
+        QVERIFY(QMetaType(type).load(stream, value));
 
     stream.device()->seek(0);
     stream.resetStatus();
-    QCOMPARE(QMetaType::load(stream, type, value), isStreamable);
+    QCOMPARE(QMetaType(type).load(stream, value), isStreamable);
     QCOMPARE(stream.status(), QDataStream::Ok);
 
     if (isStreamable)
-        QVERIFY(QMetaType::load(stream, type, value));
+        QVERIFY(QMetaType(type).load(stream, value));
 
-    QMetaType::destroy(type, value);
+    QMetaType(type).destroy(value);
 }
 
 QTEST_MAIN(tst_QGuiMetaType)
diff --git a/tests/auto/gui/kernel/qguivariant/test/tst_qguivariant.cpp b/tests/auto/gui/kernel/qguivariant/test/tst_qguivariant.cpp
index 22ca31fcb7..4983db579a 100644
--- a/tests/auto/gui/kernel/qguivariant/test/tst_qguivariant.cpp
+++ b/tests/auto/gui/kernel/qguivariant/test/tst_qguivariant.cpp
@@ -225,7 +225,7 @@ void tst_QGuiVariant::toInt()
     QFETCH( QVariant, value );
     QFETCH( int, result );
     QFETCH( bool, valueOK );
-    QVERIFY( value.isValid() == value.canConvert( QVariant::Int ) );
+    QVERIFY(value.isValid() == value.canConvert(QMetaType(QMetaType::Int)));
     bool ok;
     int i = value.toInt( &ok );
     QCOMPARE( i, result );
@@ -255,10 +255,10 @@ void tst_QGuiVariant::toColor()
     QFETCH( QVariant, value );
     QFETCH( QColor, result );
     QVERIFY( value.isValid() );
-    QVERIFY( value.canConvert( QVariant::Color ) );
+    QVERIFY(value.canConvert(QMetaType(QMetaType::QColor)));
     QColor d = qvariant_cast<QColor>(value);
     QCOMPARE( d, result );
-    QVERIFY(value.convert(QMetaType::QColor));
+    QVERIFY(value.convert(QMetaType(QMetaType::QColor)));
     QCOMPARE(d, QColor(value.toString()));
 }
 
@@ -281,7 +281,7 @@ void tst_QGuiVariant::toPixmap()
     QFETCH( QVariant, value );
     QFETCH( QPixmap, result );
     QVERIFY( value.isValid() );
-    QVERIFY( value.canConvert( QVariant::Pixmap ) );
+    QVERIFY(value.canConvert(QMetaType(QMetaType::QPixmap)));
     QPixmap d = qvariant_cast<QPixmap>(value);
     QCOMPARE( d, result );
 }
@@ -301,7 +301,7 @@ void tst_QGuiVariant::toImage()
     QFETCH( QVariant, value );
     QFETCH( QImage, result );
     QVERIFY( value.isValid() );
-    QVERIFY( value.canConvert( QVariant::Image ) );
+    QVERIFY( value.canConvert(QMetaType(QMetaType::QImage)));
     QImage d = qvariant_cast<QImage>(value);
     QCOMPARE( d, result );
 }
@@ -323,7 +323,7 @@ void tst_QGuiVariant::toBrush()
     QFETCH( QVariant, value );
     QFETCH( QBrush, result );
     QVERIFY( value.isValid() );
-    QVERIFY( value.canConvert( QVariant::Brush ) );
+    QVERIFY(value.canConvert(QMetaType(QMetaType::QBrush)));
     QBrush d = qvariant_cast<QBrush>(value);
     QCOMPARE( d, result );
 }
@@ -342,7 +342,7 @@ void tst_QGuiVariant::toFont()
     QFETCH( QVariant, value );
     QFETCH( QFont, result );
     QVERIFY( value.isValid() );
-    QVERIFY( value.canConvert( QVariant::Font ) );
+    QVERIFY(value.canConvert(QMetaType(QMetaType::QFont)));
     QFont d = qvariant_cast<QFont>(value);
     QCOMPARE( d, result );
 }
@@ -366,7 +366,7 @@ void tst_QGuiVariant::toKeySequence()
     QFETCH( QVariant, value );
     QFETCH( QKeySequence, result );
     QVERIFY( value.isValid() );
-    QVERIFY( value.canConvert( QVariant::KeySequence ) );
+    QVERIFY(value.canConvert(QMetaType(QMetaType::QKeySequence)));
     QKeySequence d = qvariant_cast<QKeySequence>(value);
     QCOMPARE( d, result );
 }
@@ -393,7 +393,7 @@ void tst_QGuiVariant::toString()
     QFETCH( QVariant, value );
     QFETCH( QString, result );
     QVERIFY( value.isValid() );
-    QVERIFY( value.canConvert( QVariant::String ) );
+    QVERIFY(value.canConvert(QMetaType(QMetaType::QString)));
     QString str = value.toString();
     QCOMPARE( str, result );
 }
@@ -408,9 +408,9 @@ void tst_QGuiVariant::matrix4x4()
     variant.setValue(m);
     QCOMPARE(m, qvariant_cast<QMatrix4x4>(variant));
 
-    void *mmatrix = QMetaType::create(QVariant::Matrix4x4, 0);
+    void *mmatrix = QMetaType(QMetaType::QMatrix4x4).create();
     QVERIFY(mmatrix);
-    QMetaType::destroy(QVariant::Matrix4x4, mmatrix);
+    QMetaType(QMetaType::QMatrix4x4).destroy(mmatrix);
 }
 
 void tst_QGuiVariant::transform()
@@ -421,9 +421,9 @@ void tst_QGuiVariant::transform()
     variant.setValue(QTransform().rotate(90));
     QCOMPARE(QTransform().rotate(90), qvariant_cast<QTransform>(variant));
 
-    void *mmatrix = QMetaType::create(QVariant::Transform, 0);
+    void *mmatrix = QMetaType(QMetaType::QTransform).create();
     QVERIFY(mmatrix);
-    QMetaType::destroy(QVariant::Transform, mmatrix);
+    QMetaType(QMetaType::QTransform).destroy(mmatrix);
 }
 
 
@@ -435,9 +435,9 @@ void tst_QGuiVariant::vector2D()
     variant.setValue(QVector2D(0.1f, 0.2f));
     QCOMPARE(QVector2D(0.1f, 0.2f), qvariant_cast<QVector2D>(variant));
 
-    void *pvector = QMetaType::create(QVariant::Vector2D, 0);
+    void *pvector = QMetaType(QMetaType::QVector2D).create();
     QVERIFY(pvector);
-    QMetaType::destroy(QVariant::Vector2D, pvector);
+    QMetaType(QMetaType::QVector2D).destroy(pvector);
 }
 
 void tst_QGuiVariant::vector3D()
@@ -448,9 +448,9 @@ void tst_QGuiVariant::vector3D()
     variant.setValue(QVector3D(0.1f, 0.2f, 0.3f));
     QCOMPARE(QVector3D(0.1f, 0.2f, 0.3f), qvariant_cast<QVector3D>(variant));
 
-    void *pvector = QMetaType::create(QVariant::Vector3D, 0);
+    void *pvector = QMetaType(QMetaType::QVector3D).create();
     QVERIFY(pvector);
-    QMetaType::destroy(QVariant::Vector3D, pvector);
+    QMetaType(QMetaType::QVector3D).destroy(pvector);
 }
 
 void tst_QGuiVariant::vector4D()
@@ -461,9 +461,9 @@ void tst_QGuiVariant::vector4D()
     variant.setValue(QVector4D(0.1f, 0.2f, 0.3f, 0.4f));
     QCOMPARE(QVector4D(0.1f, 0.2f, 0.3f, 0.4f), qvariant_cast<QVector4D>(variant));
 
-    void *pvector = QMetaType::create(QVariant::Vector4D, 0);
+    void *pvector = QMetaType(QMetaType::QVector4D).create();
     QVERIFY(pvector);
-    QMetaType::destroy(QVariant::Vector4D, pvector);
+    QMetaType(QMetaType::QVector4D).destroy(pvector);
 }
 
 void tst_QGuiVariant::quaternion()
@@ -474,9 +474,9 @@ void tst_QGuiVariant::quaternion()
     variant.setValue(QQuaternion(0.1f, 0.2f, 0.3f, 0.4f));
     QCOMPARE(QQuaternion(0.1f, 0.2f, 0.3f, 0.4f), qvariant_cast<QQuaternion>(variant));
 
-    void *pquaternion = QMetaType::create(QVariant::Quaternion, 0);
+    void *pquaternion = QMetaType(QMetaType::QQuaternion).create();
     QVERIFY(pquaternion);
-    QMetaType::destroy(QVariant::Quaternion, pquaternion);
+    QMetaType(QMetaType::QQuaternion).destroy(pquaternion);
 }
 
 void tst_QGuiVariant::writeToReadFromDataStream_data()
@@ -513,9 +513,9 @@ void tst_QGuiVariant::writeToReadFromDataStream_data()
 void tst_QGuiVariant::invalidQColor()
 {
     QVariant va("An invalid QColor::name() value.");
-    QVERIFY(va.canConvert(QVariant::Color));
+    QVERIFY(va.canConvert(QMetaType(QMetaType::QColor)));
 
-    QVERIFY(!va.convert(QVariant::Color));
+    QVERIFY(!va.convert(QMetaType(QMetaType::QColor)));
 
     QVERIFY(!qvariant_cast<QColor>(va).isValid());
 }
@@ -524,13 +524,13 @@ void tst_QGuiVariant::validQColor()
 {
     QColor col(Qt::red);
     QVariant va(col.name());
-    QVERIFY(va.canConvert(QVariant::Color));
+    QVERIFY(va.canConvert(QMetaType(QMetaType::QColor)));
 
-    QVERIFY(va.convert(QVariant::Color));
+    QVERIFY(va.convert(QMetaType(QMetaType::QColor)));
 
     QVERIFY(col.isValid());
 
-    QVERIFY(va.convert(QVariant::String));
+    QVERIFY(va.convert(QMetaType(QMetaType::QString)));
 
     QCOMPARE(qvariant_cast<QString>(va), col.name());
 }
@@ -538,15 +538,15 @@ void tst_QGuiVariant::validQColor()
 void tst_QGuiVariant::colorInteger()
 {
     QVariant v = QColor(Qt::red);
-    QCOMPARE(v.type(), QVariant::Color);
+    QCOMPARE(v.metaType(), QMetaType(QMetaType::QColor));
     QCOMPARE(v.value<QColor>(), QColor(Qt::red));
 
     v.setValue(1000);
-    QCOMPARE(v.type(), QVariant::Int);
+    QCOMPARE(v.metaType(), QMetaType(QMetaType::Int));
     QCOMPARE(v.toInt(), 1000);
 
     v.setValue(QColor(Qt::yellow));
-    QCOMPARE(v.type(), QVariant::Color);
+    QCOMPARE(v.metaType(), QMetaType(QMetaType::QColor));
     QCOMPARE(v.value<QColor>(), QColor(Qt::yellow));
 }
 
@@ -652,7 +652,7 @@ void tst_QGuiVariant::debugStream_data()
     QTest::addColumn<QVariant>("variant");
     QTest::addColumn<int>("typeId");
     for (int id = QMetaType::FirstGuiType; id <= QMetaType::LastGuiType; ++id) {
-        const char *tagName = QMetaType::typeName(id);
+        const char *tagName = QMetaType(id).name();
         if (!tagName)
             continue;
         QTest::newRow(tagName) << QVariant(static_cast<QVariant::Type>(id)) << id;
diff --git a/tests/auto/gui/math3d/qquaternion/tst_qquaternion.cpp b/tests/auto/gui/math3d/qquaternion/tst_qquaternion.cpp
index 8041fb5439..632460f5ff 100644
--- a/tests/auto/gui/math3d/qquaternion/tst_qquaternion.cpp
+++ b/tests/auto/gui/math3d/qquaternion/tst_qquaternion.cpp
@@ -1323,10 +1323,9 @@ void tst_QQuaternion::properties()
 
 void tst_QQuaternion::metaTypes()
 {
-    QCOMPARE(QMetaType::type("QQuaternion"), int(QMetaType::QQuaternion));
+    QCOMPARE(QMetaType::fromName("QQuaternion").id(), int(QMetaType::QQuaternion));
 
-    QCOMPARE(QByteArray(QMetaType::typeName(QMetaType::QQuaternion)),
-             QByteArray("QQuaternion"));
+    QCOMPARE(QByteArray(QMetaType(QMetaType::QQuaternion).name()), QByteArray("QQuaternion"));
 
     QVERIFY(QMetaType::isRegistered(QMetaType::QQuaternion));
 
diff --git a/tests/auto/gui/math3d/qvectornd/tst_qvectornd.cpp b/tests/auto/gui/math3d/qvectornd/tst_qvectornd.cpp
index 2199f6c1e1..2085b62cdf 100644
--- a/tests/auto/gui/math3d/qvectornd/tst_qvectornd.cpp
+++ b/tests/auto/gui/math3d/qvectornd/tst_qvectornd.cpp
@@ -2662,15 +2662,15 @@ void tst_QVectorND::properties()
 
 void tst_QVectorND::metaTypes()
 {
-    QCOMPARE(QMetaType::type("QVector2D"), int(QMetaType::QVector2D));
-    QCOMPARE(QMetaType::type("QVector3D"), int(QMetaType::QVector3D));
-    QCOMPARE(QMetaType::type("QVector4D"), int(QMetaType::QVector4D));
+    QCOMPARE(QMetaType::fromName("QVector2D").id(), int(QMetaType::QVector2D));
+    QCOMPARE(QMetaType::fromName("QVector3D").id(), int(QMetaType::QVector3D));
+    QCOMPARE(QMetaType::fromName("QVector4D").id(), int(QMetaType::QVector4D));
 
-    QCOMPARE(QByteArray(QMetaType::typeName(QMetaType::QVector2D)),
+    QCOMPARE(QByteArray(QMetaType(QMetaType::QVector2D).name()),
              QByteArray("QVector2D"));
-    QCOMPARE(QByteArray(QMetaType::typeName(QMetaType::QVector3D)),
+    QCOMPARE(QByteArray(QMetaType(QMetaType::QVector3D).name()),
              QByteArray("QVector3D"));
-    QCOMPARE(QByteArray(QMetaType::typeName(QMetaType::QVector4D)),
+    QCOMPARE(QByteArray(QMetaType(QMetaType::QVector4D).name()),
              QByteArray("QVector4D"));
 
     QVERIFY(QMetaType::isRegistered(QMetaType::QVector2D));
diff --git a/tests/auto/other/qvariant_common/tst_qvariant_common.h b/tests/auto/other/qvariant_common/tst_qvariant_common.h
index 6b69d04a78..7851bf8dcc 100644
--- a/tests/auto/other/qvariant_common/tst_qvariant_common.h
+++ b/tests/auto/other/qvariant_common/tst_qvariant_common.h
@@ -56,14 +56,14 @@ protected:
         QVERIFY2(ok, (QString::fromLatin1("Message is not started correctly: '") + msg + '\'').toLatin1().constData());
         ok &= (currentId == QMetaType::UnknownType
              ? msg.contains("Invalid")
-             : msg.contains(QMetaType::typeName(currentId)));
+             : msg.contains(QMetaType(currentId).name()));
         QVERIFY2(ok, (QString::fromLatin1("Message doesn't contain type name: '") + msg + '\'').toLatin1().constData());
         if (currentId == QMetaType::Char || currentId == QMetaType::QChar) {
             // Chars insert '\0' into the qdebug stream, it is not possible to find a real string length
             return;
         }
-        if (QMetaType::typeFlags(currentId) & QMetaType::IsPointer) {
-            QByteArray currentName = QMetaType::typeName(currentId);
+        if (QMetaType(currentId).flags() & QMetaType::IsPointer) {
+            QByteArray currentName = QMetaType(currentId).name();
             ok &= msg.contains(currentName + ", 0x");
         }
         ok &= msg.endsWith(QLatin1Char(')'));
@@ -147,38 +147,38 @@ int MessageHandler::currentId;
     QFETCH(bool, ULongLongCast);
 
 #define TST_QVARIANT_CANCONVERT_COMPARE_DATA \
-    QCOMPARE(val.canConvert(QVariant::BitArray), BitArrayCast); \
-    QCOMPARE(val.canConvert(QVariant::Bitmap), BitmapCast); \
-    QCOMPARE(val.canConvert(QVariant::Bool), BoolCast); \
-    QCOMPARE(val.canConvert(QVariant::Brush), BrushCast); \
-    QCOMPARE(val.canConvert(QVariant::ByteArray), ByteArrayCast); \
-    QCOMPARE(val.canConvert(QVariant::Color), ColorCast); \
-    QCOMPARE(val.canConvert(QVariant::Cursor), CursorCast); \
-    QCOMPARE(val.canConvert(QVariant::Date), DateCast); \
-    QCOMPARE(val.canConvert(QVariant::DateTime), DateTimeCast); \
-    QCOMPARE(val.canConvert(QVariant::Double), DoubleCast); \
-    QCOMPARE(val.canConvert(QVariant::Type(QMetaType::Float)), DoubleCast); \
-    QCOMPARE(val.canConvert(QVariant::Font), FontCast); \
-    QCOMPARE(val.canConvert(QVariant::Image), ImageCast); \
-    QCOMPARE(val.canConvert(QVariant::Int), IntCast); \
-    QCOMPARE(val.canConvert(QVariant::Invalid), InvalidCast); \
-    QCOMPARE(val.canConvert(QVariant::KeySequence), KeySequenceCast); \
-    QCOMPARE(val.canConvert(QVariant::List), ListCast); \
-    QCOMPARE(val.canConvert(QVariant::LongLong), LongLongCast); \
-    QCOMPARE(val.canConvert(QVariant::Map), MapCast); \
-    QCOMPARE(val.canConvert(QVariant::Palette), PaletteCast); \
-    QCOMPARE(val.canConvert(QVariant::Pen), PenCast); \
-    QCOMPARE(val.canConvert(QVariant::Pixmap), PixmapCast); \
-    QCOMPARE(val.canConvert(QVariant::Point), PointCast); \
-    QCOMPARE(val.canConvert(QVariant::Rect), RectCast); \
-    QCOMPARE(val.canConvert(QVariant::Region), RegionCast); \
-    QCOMPARE(val.canConvert(QVariant::Size), SizeCast); \
-    QCOMPARE(val.canConvert(QVariant::SizePolicy), SizePolicyCast); \
-    QCOMPARE(val.canConvert(QVariant::String), StringCast); \
-    QCOMPARE(val.canConvert(QVariant::StringList), StringListCast); \
-    QCOMPARE(val.canConvert(QVariant::Time), TimeCast); \
-    QCOMPARE(val.canConvert(QVariant::UInt), UIntCast); \
-    QCOMPARE(val.canConvert(QVariant::ULongLong), ULongLongCast);
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QBitArray)), BitArrayCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QBitmap)), BitmapCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::Bool)), BoolCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QBrush)), BrushCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QByteArray)), ByteArrayCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QColor)), ColorCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QCursor)), CursorCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QDate)), DateCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QDateTime)), DateTimeCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::Double)), DoubleCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::Float)), DoubleCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QFont)), FontCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QImage)), ImageCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::Int)), IntCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::UnknownType)), InvalidCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QKeySequence)), KeySequenceCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QVariantList)), ListCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::LongLong)), LongLongCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QVariantMap)), MapCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QPalette)), PaletteCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QPen)), PenCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QPixmap)), PixmapCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QPoint)), PointCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QRect)), RectCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QRegion)), RegionCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QSize)), SizeCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QSizePolicy)), SizePolicyCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QString)), StringCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QStringList)), StringListCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::QTime)), TimeCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::UInt)), UIntCast); \
+    QCOMPARE(val.canConvert(QMetaType(QMetaType::ULongLong)), ULongLongCast);
 
 
 #endif
diff --git a/tests/auto/widgets/kernel/qwidgetmetatype/tst_qwidgetmetatype.cpp b/tests/auto/widgets/kernel/qwidgetmetatype/tst_qwidgetmetatype.cpp
index 0c99042e10..300320ca5d 100644
--- a/tests/auto/widgets/kernel/qwidgetmetatype/tst_qwidgetmetatype.cpp
+++ b/tests/auto/widgets/kernel/qwidgetmetatype/tst_qwidgetmetatype.cpp
@@ -64,10 +64,10 @@ static_assert((!QMetaTypeId2<QMap<QString,QSizePolicy> >::IsBuiltIn));
 
 void tst_QWidgetMetaType::metaObject()
 {
-    QCOMPARE(QMetaType::metaObjectForType(qMetaTypeId<QWidget*>()), &QWidget::staticMetaObject);
-    QCOMPARE(QMetaType::metaObjectForType(qMetaTypeId<QLabel*>()), &QLabel::staticMetaObject);
-    QCOMPARE(QMetaType::metaObjectForType(qMetaTypeId<CustomWidget*>()), &CustomWidget::staticMetaObject);
-    QCOMPARE(QMetaType::metaObjectForType(qMetaTypeId<QSizePolicy>()), &QSizePolicy::staticMetaObject);
+    QCOMPARE(QMetaType::fromType<QWidget*>().metaObject(), &QWidget::staticMetaObject);
+    QCOMPARE(QMetaType::fromType<QLabel*>().metaObject(), &QLabel::staticMetaObject);
+    QCOMPARE(QMetaType::fromType<CustomWidget*>().metaObject(), &CustomWidget::staticMetaObject);
+    QCOMPARE(QMetaType::fromType<QSizePolicy>().metaObject(), &QSizePolicy::staticMetaObject);
 }
 
 template <typename T>
@@ -93,25 +93,25 @@ void tst_QWidgetMetaType::saveAndLoadBuiltin()
     QFETCH(int, type);
     QFETCH(bool, isStreamable);
 
-    void *value = QMetaType::create(type);
+    void *value = QMetaType(type).create();
 
     QByteArray ba;
     QDataStream stream(&ba, QIODevice::ReadWrite);
-    QCOMPARE(QMetaType::save(stream, type, value), isStreamable);
+    QCOMPARE(QMetaType(type).save(stream, value), isStreamable);
     QCOMPARE(stream.status(), QDataStream::Ok);
 
     if (isStreamable)
-        QVERIFY(QMetaType::load(stream, type, value));
+        QVERIFY(QMetaType(type).load(stream, value));
 
     stream.device()->seek(0);
     stream.resetStatus();
-    QCOMPARE(QMetaType::load(stream, type, value), isStreamable);
+    QCOMPARE(QMetaType(type).load(stream, value), isStreamable);
     QCOMPARE(stream.status(), QDataStream::Ok);
 
     if (isStreamable)
-        QVERIFY(QMetaType::load(stream, type, value));
+        QVERIFY(QMetaType(type).load(stream, value));
 
-    QMetaType::destroy(type, value);
+    QMetaType(type).destroy(value);
 }
 
 
diff --git a/tests/auto/widgets/kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp b/tests/auto/widgets/kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp
index d91cb92370..95bad0e903 100644
--- a/tests/auto/widgets/kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp
+++ b/tests/auto/widgets/kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp
@@ -176,24 +176,24 @@ void tst_QWidgetsVariant::qvariant_cast_QObject()
     if (success) {
         QCOMPARE(o->objectName(), QString::fromLatin1("Hello"));
         QVERIFY(data.canConvert<QObject*>());
-        QVERIFY(data.canConvert(QMetaType::QObjectStar));
-        QVERIFY(data.canConvert(::qMetaTypeId<QObject*>()));
+        QVERIFY(data.canConvert(QMetaType(QMetaType::QObjectStar)));
+        QVERIFY(data.canConvert(QMetaType::fromType<QObject*>()));
         QVERIFY(data.value<QObject*>());
-        QVERIFY(data.convert(QMetaType::QObjectStar));
-        QCOMPARE(data.userType(), int(QMetaType::QObjectStar));
+        QVERIFY(data.convert(QMetaType(QMetaType::QObjectStar)));
+        QCOMPARE(data.metaType().id(), int(QMetaType::QObjectStar));
 
         QVERIFY(data.canConvert<QWidget*>());
-        QVERIFY(data.canConvert(::qMetaTypeId<QWidget*>()));
+        QVERIFY(data.canConvert(QMetaType::fromType<QWidget*>()));
         QVERIFY(data.value<QWidget*>());
-        QVERIFY(data.convert(qMetaTypeId<QWidget*>()));
-        QCOMPARE(data.userType(), qMetaTypeId<QWidget*>());
+        QVERIFY(data.convert(QMetaType::fromType<QWidget*>()));
+        QCOMPARE(data.metaType(), QMetaType::fromType<QWidget*>());
     } else {
         QVERIFY(!data.canConvert<QObject*>());
-        QVERIFY(!data.canConvert(QMetaType::QObjectStar));
-        QVERIFY(!data.canConvert(::qMetaTypeId<QObject*>()));
+        QVERIFY(!data.canConvert(QMetaType(QMetaType::QObjectStar)));
+        QVERIFY(!data.canConvert(QMetaType::fromType<QObject*>()));
         QVERIFY(!data.value<QObject*>());
-        QVERIFY(!data.convert(QMetaType::QObjectStar));
-        QVERIFY(data.userType() != QMetaType::QObjectStar);
+        QVERIFY(!data.convert(QMetaType(QMetaType::QObjectStar)));
+        QVERIFY(data.metaType().id() != QMetaType::QObjectStar);
     }
     delete o;
 }
@@ -215,7 +215,7 @@ void tst_QWidgetsVariant::debugStream_data()
     QTest::addColumn<QVariant>("variant");
     QTest::addColumn<int>("typeId");
     for (int id = QMetaType::LastGuiType + 1; id < QMetaType::User; ++id) {
-        const char *tagName = QMetaType::typeName(id);
+        const char *tagName = QMetaType(id).name();
         if (!tagName)
             continue;
         QTest::newRow(tagName) << QVariant(static_cast<QVariant::Type>(id)) << id;