Make most of QMetaTypeInterface constexpr

The only thing we need to modify at runtime is the typeId and that can
be mutable. This way we can have a constexpr ctor for QMetaType which
hopefully makes the importing and exporting of related symbols less
fickle.

On Windows we cannot make QMetaTypeForType constexpr as that leads to
mysterious errors in other places. Until we figure out why that is, we
just leave this class as non-constexpr.

This reveals that qcoreapplication.h and qvariant.h are using QDebug
without including it. We now get template instantiation errors. Include
qdebug.h to avoid that.

Change-Id: If1bf0437ada52459c59c6fa45bab3d22dfb0bc92
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

7 files changed, 86 insertions, 68 deletions

diff --git a/src/corelib/kernel/qcoreapplication.h b/src/corelib/kernel/qcoreapplication.h
index a67ac29bb9..8a30aa25c9 100644
--- a/src/corelib/kernel/qcoreapplication.h
+++ b/src/corelib/kernel/qcoreapplication.h
@@ -49,6 +49,9 @@
 #else
 #include <QtCore/qscopedpointer.h>
 #endif
+#ifndef QT_NO_DEBUGSTREAM
+#include <QtCore/qdebug.h>
+#endif
 
 #ifndef QT_NO_QOBJECT
 #if defined(Q_OS_WIN) && !defined(tagMSG)
diff --git a/src/corelib/kernel/qmetacontainer.h b/src/corelib/kernel/qmetacontainer.h
index a873bb2106..4bce731d8a 100644
--- a/src/corelib/kernel/qmetacontainer.h
+++ b/src/corelib/kernel/qmetacontainer.h
@@ -50,7 +50,7 @@ class QMetaType;
 namespace QtPrivate {
 class QMetaTypeInterface;
 template<typename T>
-constexpr QMetaTypeInterface *qMetaTypeInterfaceForType();
+constexpr const QMetaTypeInterface *qMetaTypeInterfaceForType();
 }
 
 namespace QtMetaContainerPrivate {
@@ -132,7 +132,7 @@ public:
 class QMetaSequenceInterface : public QMetaContainerInterface
 {
 public:
-    QtPrivate::QMetaTypeInterface *valueMetaType;
+    const QtPrivate::QMetaTypeInterface *valueMetaType;
     AddRemoveCapabilities addRemoveCapabilities;
 
     using ValueAtIndexFn = void(*)(const void *, qsizetype, void *);
@@ -183,8 +183,8 @@ public:
 class QMetaAssociationInterface : public QMetaContainerInterface
 {
 public:
-    QtPrivate::QMetaTypeInterface *keyMetaType;
-    QtPrivate::QMetaTypeInterface *mappedMetaType;
+    const QtPrivate::QMetaTypeInterface *keyMetaType;
+    const QtPrivate::QMetaTypeInterface *mappedMetaType;
 
     using InsertKeyFn = void(*)(void *, const void *);
     InsertKeyFn insertKeyFn;
@@ -470,7 +470,7 @@ class QMetaSequenceForContainer : public QMetaContainerForContainer<C>
 {
     friend QMetaSequenceInterface;
 
-    static constexpr QtPrivate::QMetaTypeInterface *getValueMetaType()
+    static constexpr const QtPrivate::QMetaTypeInterface *getValueMetaType()
     {
         if constexpr (QContainerTraits::has_value_type_v<C>)
             return QtPrivate::qMetaTypeInterfaceForType<typename C::value_type>();
@@ -697,7 +697,7 @@ class QMetaAssociationForContainer : public QMetaContainerForContainer<C>
 {
     friend QMetaAssociationInterface;
 
-    static constexpr QtPrivate::QMetaTypeInterface *getKeyMetaType()
+    static constexpr const QtPrivate::QMetaTypeInterface *getKeyMetaType()
     {
         if constexpr (QContainerTraits::has_key_type_v<C>)
             return QtPrivate::qMetaTypeInterfaceForType<typename C::key_type>();
@@ -705,7 +705,7 @@ class QMetaAssociationForContainer : public QMetaContainerForContainer<C>
             return nullptr;
     }
 
-    static constexpr QtPrivate::QMetaTypeInterface *getMappedMetaType()
+    static constexpr const QtPrivate::QMetaTypeInterface *getMappedMetaType()
     {
         if constexpr (QContainerTraits::has_mapped_type_v<C>)
             return QtPrivate::qMetaTypeInterfaceForType<typename C::mapped_type>();
diff --git a/src/corelib/kernel/qmetatype.cpp b/src/corelib/kernel/qmetatype.cpp
index c9a0a40cd0..d9de26141c 100644
--- a/src/corelib/kernel/qmetatype.cpp
+++ b/src/corelib/kernel/qmetatype.cpp
@@ -107,12 +107,12 @@ struct DefinedTypesFilter {
 struct QMetaTypeCustomRegistry
 {
     QReadWriteLock lock;
-    QList<QtPrivate::QMetaTypeInterface *> registry;
-    QHash<QByteArray, QtPrivate::QMetaTypeInterface *> aliases;
+    QList<const QtPrivate::QMetaTypeInterface *> registry;
+    QHash<QByteArray, const QtPrivate::QMetaTypeInterface *> aliases;
     // index of first empty (unregistered) type in registry, if any.
     int firstEmpty = 0;
 
-    int registerCustomType(QtPrivate::QMetaTypeInterface *ti)
+    int registerCustomType(const QtPrivate::QMetaTypeInterface *ti)
     {
         {
             QWriteLocker l(&lock);
@@ -168,7 +168,7 @@ struct QMetaTypeCustomRegistry
         firstEmpty = std::min(firstEmpty, idx);
     }
 
-    QtPrivate::QMetaTypeInterface *getCustomType(int id)
+    const QtPrivate::QMetaTypeInterface *getCustomType(int id)
     {
         QReadLocker l(&lock);
         return registry.value(id - QMetaType::User - 1);
@@ -847,7 +847,7 @@ static const struct : QMetaTypeModuleHelper
         return !(str.isEmpty() || str == LiteralWrapper("0") || str == LiteralWrapper("false"));
     }
 
-    QtPrivate::QMetaTypeInterface *interfaceForType(int type) const override {
+    const QtPrivate::QMetaTypeInterface *interfaceForType(int type) const override {
         switch (type) {
             QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(QT_METATYPE_CONVERT_ID_TO_TYPE)
             QT_FOR_EACH_STATIC_PRIMITIVE_POINTER(QT_METATYPE_CONVERT_ID_TO_TYPE)
@@ -2898,9 +2898,9 @@ QMetaType QMetaType::fromName(QByteArrayView typeName)
     \sa Q_DECLARE_METATYPE(), QMetaType::type()
 */
 
-static QtPrivate::QMetaTypeInterface *interfaceForType(int typeId)
+static const QtPrivate::QMetaTypeInterface *interfaceForType(int typeId)
 {
-    QtPrivate::QMetaTypeInterface *iface = nullptr;
+    const QtPrivate::QMetaTypeInterface *iface = nullptr;
     if (typeId >= QMetaType::User) {
         if (auto reg = customTypeRegistry())
             iface = reg->getCustomType(typeId);
diff --git a/src/corelib/kernel/qmetatype.h b/src/corelib/kernel/qmetatype.h
index 3b84327e91..5eb89e8552 100644
--- a/src/corelib/kernel/qmetatype.h
+++ b/src/corelib/kernel/qmetatype.h
@@ -399,7 +399,7 @@ public:
     static bool isRegistered(int type);
 
     explicit QMetaType(int type);
-    explicit constexpr QMetaType(QtPrivate::QMetaTypeInterface *d) : d_ptr(d) {}
+    explicit constexpr QMetaType(const QtPrivate::QMetaTypeInterface *d) : d_ptr(d) {}
     constexpr QMetaType() = default;
 
     bool isValid() const;
@@ -436,7 +436,7 @@ public:
 #endif
 
     template<typename T>
-    static QMetaType fromType();
+    constexpr static QMetaType fromType();
     static QMetaType fromName(QByteArrayView name);
 
     friend bool operator==(QMetaType a, QMetaType b) { return a.d_ptr == b.d_ptr || a.id() == b.id(); }
@@ -647,11 +647,11 @@ public:
     static void unregisterMutableViewFunction(QMetaType from, QMetaType to);
 
     static void unregisterMetaType(QMetaType type);
-    QtPrivate::QMetaTypeInterface *iface() { return d_ptr; }
+    const QtPrivate::QMetaTypeInterface *iface() { return d_ptr; }
 
 private:
     friend class QVariant;
-    QtPrivate::QMetaTypeInterface *d_ptr = nullptr;
+    const QtPrivate::QMetaTypeInterface *d_ptr = nullptr;
 };
 
 #undef QT_DEFINE_METATYPE_ID
@@ -1610,7 +1610,7 @@ public:
     ushort alignment;
     uint size;
     uint flags;
-    QBasicAtomicInt typeId;
+    mutable QBasicAtomicInt typeId;
     const QMetaObject *metaObject;
     const char *name;
 
@@ -2179,56 +2179,52 @@ struct QDataStreamOperatorForType <T, false>
 template<typename S>
 class QMetaTypeForType
 {
+public:
     static constexpr decltype(typenameHelper<S>()) name = typenameHelper<S>();
 
-    template<typename T>
     static constexpr QMetaTypeInterface::DefaultCtrFn getDefaultCtr()
     {
-      if constexpr (std::is_default_constructible_v<T>) {
-        return [](const QMetaTypeInterface *, void *addr) { new (addr) T(); };
+      if constexpr (std::is_default_constructible_v<S>) {
+        return [](const QMetaTypeInterface *, void *addr) { new (addr) S(); };
       } else {
         return nullptr;
       }
     }
 
-    template<typename T>
     static constexpr QMetaTypeInterface::CopyCtrFn getCopyCtr()
     {
-      if constexpr (std::is_copy_constructible_v<T>) {
+      if constexpr (std::is_copy_constructible_v<S>) {
         return [](const QMetaTypeInterface *, void *addr, const void *other) {
-          new (addr) T(*reinterpret_cast<const T *>(other));
+          new (addr) S(*reinterpret_cast<const S *>(other));
         };
       } else {
         return nullptr;
       }
     }
 
-    template<typename T>
     static constexpr QMetaTypeInterface::MoveCtrFn getMoveCtr()
     {
-      if constexpr (std::is_move_constructible_v<T>) {
+      if constexpr (std::is_move_constructible_v<S>) {
         return [](const QMetaTypeInterface *, void *addr, void *other) {
-          new (addr) T(std::move(*reinterpret_cast<T *>(other)));
+          new (addr) S(std::move(*reinterpret_cast<S *>(other)));
         };
       } else {
         return nullptr;
       }
     }
 
-    template<typename T>
     static constexpr QMetaTypeInterface::DtorFn getDtor()
     {
-      if constexpr (std::is_destructible_v<T>)
-        return [](const QMetaTypeInterface *, void *addr) { reinterpret_cast<T *>(addr)->~T(); };
+      if constexpr (std::is_destructible_v<S>)
+        return [](const QMetaTypeInterface *, void *addr) { reinterpret_cast<S *>(addr)->~S(); };
       else
         return nullptr;
     }
 
-    template<typename T>
     static constexpr QMetaTypeInterface::LegacyRegisterOp getLegacyRegister()
     {
-      if constexpr (QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn) {
-        return []() { QMetaTypeId2<T>::qt_metatype_id(); };
+      if constexpr (QMetaTypeId2<S>::Defined && !QMetaTypeId2<S>::IsBuiltIn) {
+        return []() { QMetaTypeId2<S>::qt_metatype_id(); };
       } else {
         return nullptr;
       }
@@ -2242,37 +2238,53 @@ class QMetaTypeForType
             return name.data();
         }
     }
-
-public:
-    static QMetaTypeInterface metaType;
 };
 
 template<typename T>
-QMetaTypeInterface QMetaTypeForType<T>::metaType = {
-    /*.revision=*/ 0,
-    /*.alignment=*/ alignof(T),
-    /*.size=*/ sizeof(T),
-    /*.flags=*/ QMetaTypeTypeFlags<T>::Flags,
-    /*.typeId=*/ BuiltinMetaType<T>::value,
-    /*.metaObject=*/ MetaObjectForType<T>::value(),
-    /*.name=*/ getName(),
-    /*.defaultCtr=*/ getDefaultCtr<T>(),
-    /*.copyCtr=*/ getCopyCtr<T>(),
-    /*.moveCtr=*/ getMoveCtr<T>(),
-    /*.dtor=*/ getDtor<T>(),
-    /*.equals=*/ QEqualityOperatorForType<T>::equals,
-    /*.lessThan=*/ QLessThanOperatorForType<T>::lessThan,
-    /*.debugStream=*/ QDebugStreamOperatorForType<T>::debugStream,
-    /*.dataStreamOut=*/ QDataStreamOperatorForType<T>::dataStreamOut,
-    /*.dataStreamIn=*/ QDataStreamOperatorForType<T>::dataStreamIn,
-    /*.legacyRegisterOp=*/ getLegacyRegister<T>()
+struct QMetaTypeInterfaceWrapper
+{
+    static inline constexpr QMetaTypeInterface create()
+    {
+        return {
+            /*.revision=*/ 0,
+            /*.alignment=*/ alignof(T),
+            /*.size=*/ sizeof(T),
+            /*.flags=*/ QMetaTypeTypeFlags<T>::Flags,
+            /*.typeId=*/ BuiltinMetaType<T>::value,
+            /*.metaObject=*/ MetaObjectForType<T>::value(),
+            /*.name=*/ QMetaTypeForType<T>::getName(),
+            /*.defaultCtr=*/ QMetaTypeForType<T>::getDefaultCtr(),
+            /*.copyCtr=*/ QMetaTypeForType<T>::getCopyCtr(),
+            /*.moveCtr=*/ QMetaTypeForType<T>::getMoveCtr(),
+            /*.dtor=*/ QMetaTypeForType<T>::getDtor(),
+            /*.equals=*/ QEqualityOperatorForType<T>::equals,
+            /*.lessThan=*/ QLessThanOperatorForType<T>::lessThan,
+            /*.debugStream=*/ QDebugStreamOperatorForType<T>::debugStream,
+            /*.dataStreamOut=*/ QDataStreamOperatorForType<T>::dataStreamOut,
+            /*.dataStreamIn=*/ QDataStreamOperatorForType<T>::dataStreamIn,
+            /*.legacyRegisterOp=*/ QMetaTypeForType<T>::getLegacyRegister()
+        };
+    }
+
+#ifdef Q_OS_WIN
+    // MSVC produces link errors when the metaType is constexpr
+    static const QMetaTypeInterface metaType;
+#else
+    static constexpr const QMetaTypeInterface metaType = create();
+#endif
 };
 
+#ifdef Q_OS_WIN
+template<typename T>
+const QMetaTypeInterface QMetaTypeInterfaceWrapper<T>::metaType
+    = QMetaTypeInterfaceWrapper<T>::create();
+#endif
+
 template<>
-class QMetaTypeForType<void>
+class QMetaTypeInterfaceWrapper<void>
 {
 public:
-    static inline QMetaTypeInterface metaType =
+    static constexpr QMetaTypeInterface metaType =
     {
         /*.revision=*/ 0,
         /*.alignment=*/ 0,
@@ -2318,10 +2330,10 @@ QT_FOR_EACH_STATIC_CORE_TEMPLATE(QT_METATYPE_DECLARE_EXTERN_TEMPLATE_ITER)
 #endif
 
 template<typename T>
-constexpr QMetaTypeInterface *qMetaTypeInterfaceForType()
+constexpr const QMetaTypeInterface *qMetaTypeInterfaceForType()
 {
     using Ty = std::remove_cv_t<std::remove_reference_t<T>>;
-    return &QMetaTypeForType<Ty>::metaType;
+    return &QMetaTypeInterfaceWrapper<Ty>::metaType;
 }
 
 namespace detail {
@@ -2365,7 +2377,7 @@ struct TypeAndForceComplete
 };
 
 template<typename Unique, typename TypeCompletePair>
-constexpr QMetaTypeInterface *qTryMetaTypeInterfaceForType()
+constexpr const QMetaTypeInterface *qTryMetaTypeInterfaceForType()
 {
     using T = typename TypeCompletePair::type;
     using ForceComplete = typename TypeCompletePair::ForceComplete;
@@ -2374,25 +2386,25 @@ constexpr QMetaTypeInterface *qTryMetaTypeInterfaceForType()
     if constexpr (!is_complete<Tz, Unique>::value && !ForceComplete::value) {
         return nullptr;
     } else {
-        return &QMetaTypeForType<Ty>::metaType;
+        return &QMetaTypeInterfaceWrapper<Ty>::metaType;
     }
 }
 
 } // namespace QtPrivate
 
 template<typename T>
-QMetaType QMetaType::fromType()
+constexpr QMetaType QMetaType::fromType()
 {
     return QMetaType(QtPrivate::qMetaTypeInterfaceForType<T>());
 }
 
 template<typename... T>
-QtPrivate::QMetaTypeInterface *const qt_metaTypeArray[] = {
+constexpr const QtPrivate::QMetaTypeInterface *const qt_metaTypeArray[] = {
     QtPrivate::qMetaTypeInterfaceForType<T>()...
 };
 
 template<typename Unique,typename... T>
-QtPrivate::QMetaTypeInterface *const qt_incomplete_metaTypeArray[] = {
+constexpr const QtPrivate::QMetaTypeInterface *const qt_incomplete_metaTypeArray[] = {
     QtPrivate::qTryMetaTypeInterfaceForType<Unique, T>()...
 };
 
diff --git a/src/corelib/kernel/qmetatype_p.h b/src/corelib/kernel/qmetatype_p.h
index 9229dd8584..69ad03cf33 100644
--- a/src/corelib/kernel/qmetatype_p.h
+++ b/src/corelib/kernel/qmetatype_p.h
@@ -154,7 +154,7 @@ public:
         return (quint64(from) << 32) + quint64(to);
     };
 
-    virtual QtPrivate::QMetaTypeInterface *interfaceForType(int) const = 0;
+    virtual const QtPrivate::QMetaTypeInterface *interfaceForType(int) const = 0;
     virtual bool convert(const void *, int, void *, int) const { return false; }
 };
 
@@ -221,10 +221,10 @@ template<> struct TypeDefinition<QIcon> { static const bool IsAvailable = false;
 #endif
 
 template<typename T>
-static QT_PREPEND_NAMESPACE(QtPrivate::QMetaTypeInterface) *getInterfaceFromType()
+static const QT_PREPEND_NAMESPACE(QtPrivate::QMetaTypeInterface) *getInterfaceFromType()
 {
     if constexpr (QtMetaTypePrivate::TypeDefinition<T>::IsAvailable) {
-        return &QT_PREPEND_NAMESPACE(QtPrivate::QMetaTypeForType)<T>::metaType;
+        return &QT_PREPEND_NAMESPACE(QtPrivate::QMetaTypeInterfaceWrapper)<T>::metaType;
     }
     return nullptr;
 }
diff --git a/src/corelib/kernel/qobjectdefs.h b/src/corelib/kernel/qobjectdefs.h
index 38a87e2dcb..2c1415f7b6 100644
--- a/src/corelib/kernel/qobjectdefs.h
+++ b/src/corelib/kernel/qobjectdefs.h
@@ -429,7 +429,7 @@ struct Q_CORE_EXPORT QMetaObject
         typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
         StaticMetacallFunction static_metacall;
         const SuperData *relatedMetaObjects;
-        QtPrivate::QMetaTypeInterface *const *metaTypes;
+        const QtPrivate::QMetaTypeInterface *const *metaTypes;
         void *extradata; //reserved for future use
     } d;
 
diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h
index 9df9c53802..40d3d5c3b1 100644
--- a/src/corelib/kernel/qvariant.h
+++ b/src/corelib/kernel/qvariant.h
@@ -49,6 +49,9 @@
 #include <QtCore/qstring.h>
 #include <QtCore/qstringlist.h>
 #include <QtCore/qobject.h>
+#ifndef QT_NO_DEBUG_STREAM
+#include <QtCore/qdebug.h>
+#endif
 #ifndef QT_BOOTSTRAPPED
 #include <QtCore/qbytearraylist.h>
 #endif