Deprecate QVariant::Type

It's been obsolete for a long time already. Make sure
the compiler now warns about it and remove all remaining
uses in qtbase.

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

4 files changed, 120 insertions, 93 deletions

diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp
index 3bb3e33465..1c9c684ef7 100644
--- a/src/corelib/kernel/qmetaobject.cpp
+++ b/src/corelib/kernel/qmetaobject.cpp
@@ -2941,21 +2941,16 @@ const char *QMetaProperty::typeName() const
     return rawTypeNameFromTypeInfo(mobj, data.type());
 }
 
-/*!
+/*! \fn QVariant::Type QMetaProperty::type() const
+    \deprecated
+
     Returns this property's type. The return value is one
     of the values of the QVariant::Type enumeration.
 
-    \sa userType(), typeName(), name(), metaType()
+    \sa metaType().id(), typeName(), name(), metaType()
 */
-QVariant::Type QMetaProperty::type() const
-{
-    uint type = userType();
-    if (type >= QMetaType::User)
-        return QVariant::UserType;
-    return QVariant::Type(type);
-}
 
-/*!
+/*! \fn int QMetaProperty::userType() const
     \since 4.2
 
     Returns this property's user type. The return value is one
@@ -2965,12 +2960,6 @@ QVariant::Type QMetaProperty::type() const
 
     \sa type(), QMetaType, typeName(), metaType()
  */
-int QMetaProperty::userType() const
-{
-    if (!mobj)
-        return QMetaType::UnknownType;
-    return QMetaType(mobj->d.metaTypes[data.index(mobj)]).id();
-}
 
 /*!
     \since 6.0
@@ -3197,7 +3186,7 @@ bool QMetaProperty::write(QObject *object, const QVariant &value) const
     QVariant v = value;
     QMetaType t(mobj->d.metaTypes[data.index(mobj)]);
     if (t != QMetaType::fromType<QVariant>() && t != v.metaType()) {
-        if (isEnumType() && !t.metaObject() && v.userType() == QMetaType::QString) {
+        if (isEnumType() && !t.metaObject() && v.metaType().id() == QMetaType::QString) {
             // Assigning a string to a property of type Q_ENUMS (instead of Q_ENUM)
             bool ok;
             if (isFlagType())
diff --git a/src/corelib/kernel/qmetaobject.h b/src/corelib/kernel/qmetaobject.h
index 08c57d5f28..686e4aeeb8 100644
--- a/src/corelib/kernel/qmetaobject.h
+++ b/src/corelib/kernel/qmetaobject.h
@@ -280,8 +280,15 @@ public:
 
     const char *name() const;
     const char *typeName() const;
-    QVariant::Type type() const;
-    int userType() const;
+#if QT_DEPRECATED_SINCE(6, 0)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
+    QT_DEPRECATED_VERSION_6_0
+    QVariant::Type type() const
+    { int t = userType(); return t >= QMetaType::User ? QVariant::UserType : QVariant::Type(t); }
+    QT_WARNING_POP
+#endif
+    int userType() const { return metaType().id(); }
     QMetaType metaType() const;
     int propertyIndex() const;
     int relativePropertyIndex() const;
diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp
index 56e428b052..f7652e28d4 100644
--- a/src/corelib/kernel/qvariant.cpp
+++ b/src/corelib/kernel/qvariant.cpp
@@ -765,15 +765,15 @@ QVariant::QVariant(const QVariant &p)
   Constructs a new variant with the regular expression value \a re.
 */
 
-/*!
+/*! \fn QVariant::QVariant(Type type)
+    \deprecated
+
     Constructs an uninitialized variant of type \a type. This will create a
     variant in a special null state that if accessed will return a default
     constructed value of the \a type.
 
     \sa isNull()
 */
-QVariant::QVariant(Type type)
-{ create(type, nullptr); }
 
 /*!
     Constructs variant of type \a type, and initializes with
@@ -793,110 +793,110 @@ QVariant::QVariant(QMetaType type, const void *copy) : d(type)
 }
 
 QVariant::QVariant(int val)
-    : d(Int)
+    : d(QMetaType::Int)
 { d.set(val); }
 QVariant::QVariant(uint val)
-    : d(UInt)
+    : d(QMetaType::UInt)
 { d.set(val); }
 QVariant::QVariant(qlonglong val)
-    : d(LongLong)
+    : d(QMetaType::LongLong)
 { d.set(val); }
 QVariant::QVariant(qulonglong val)
-    : d(ULongLong)
+    : d(QMetaType::ULongLong)
 { d.set(val); }
 QVariant::QVariant(bool val)
-    : d(Bool)
+    : d(QMetaType::Bool)
 { d.set(val); }
 QVariant::QVariant(double val)
-    : d(Double)
+    : d(QMetaType::Double)
 { d.set(val); }
 QVariant::QVariant(float val)
     : d(QMetaType::Float)
 { d.set(val); }
 
 QVariant::QVariant(const QByteArray &val)
-    : d(ByteArray)
+    : d(QMetaType::QByteArray)
 { v_construct<QByteArray>(&d, val); }
 QVariant::QVariant(const QBitArray &val)
-    : d(BitArray)
+    : d(QMetaType::QBitArray)
 { v_construct<QBitArray>(&d, val);  }
 QVariant::QVariant(const QString &val)
-    : d(String)
+    : d(QMetaType::QString)
 { v_construct<QString>(&d, val);  }
 QVariant::QVariant(QChar val)
-    : d(Char)
+    : d(QMetaType::QChar)
 { v_construct<QChar>(&d, val);  }
 QVariant::QVariant(QLatin1String val)
-    : d(String)
+    : d(QMetaType::QString)
 { v_construct<QString>(&d, val); }
 QVariant::QVariant(const QStringList &val)
-    : d(StringList)
+    : d(QMetaType::QStringList)
 { v_construct<QStringList>(&d, val); }
 
 QVariant::QVariant(QDate val)
-    : d(Date)
+    : d(QMetaType::QDate)
 { v_construct<QDate>(&d, val); }
 QVariant::QVariant(QTime val)
-    : d(Time)
+    : d(QMetaType::QTime)
 { v_construct<QTime>(&d, val); }
 QVariant::QVariant(const QDateTime &val)
-    : d(DateTime)
+    : d(QMetaType::QDateTime)
 { v_construct<QDateTime>(&d, val); }
 #if QT_CONFIG(easingcurve)
 QVariant::QVariant(const QEasingCurve &val)
-    : d(EasingCurve)
+    : d(QMetaType::QEasingCurve)
 { v_construct<QEasingCurve>(&d, val); }
 #endif
 QVariant::QVariant(const QList<QVariant> &list)
-    : d(List)
+    : d(QMetaType::QVariantList)
 { v_construct<QVariantList>(&d, list); }
 QVariant::QVariant(const QMap<QString, QVariant> &map)
-    : d(Map)
+    : d(QMetaType::QVariantMap)
 { v_construct<QVariantMap>(&d, map); }
 QVariant::QVariant(const QHash<QString, QVariant> &hash)
-    : d(Hash)
+    : d(QMetaType::QVariantHash)
 { v_construct<QVariantHash>(&d, hash); }
 #ifndef QT_NO_GEOM_VARIANT
 QVariant::QVariant(const QPoint &pt)
-    : d(Point)
+    : d(QMetaType::QPoint)
 { v_construct<QPoint>(&d, pt); }
 QVariant::QVariant(const QPointF &pt)
-    : d(PointF)
+    : d(QMetaType::QPointF)
 { v_construct<QPointF>(&d, pt); }
 QVariant::QVariant(const QRectF &r)
-    : d(RectF)
+    : d(QMetaType::QRectF)
 { v_construct<QRectF>(&d, r); }
 QVariant::QVariant(const QLineF &l)
-    : d(LineF)
+    : d(QMetaType::QLineF)
 { v_construct<QLineF>(&d, l); }
 QVariant::QVariant(const QLine &l)
-    : d(Line)
+    : d(QMetaType::QLine)
 { v_construct<QLine>(&d, l); }
 QVariant::QVariant(const QRect &r)
-    : d(Rect)
+    : d(QMetaType::QRect)
 { v_construct<QRect>(&d, r); }
 QVariant::QVariant(const QSize &s)
-    : d(Size)
+    : d(QMetaType::QSize)
 { v_construct<QSize>(&d, s); }
 QVariant::QVariant(const QSizeF &s)
-    : d(SizeF)
+    : d(QMetaType::QSizeF)
 { v_construct<QSizeF>(&d, s); }
 #endif
 #ifndef QT_BOOTSTRAPPED
 QVariant::QVariant(const QUrl &u)
-    : d(Url)
+    : d(QMetaType::QUrl)
 { v_construct<QUrl>(&d, u); }
 #endif
 QVariant::QVariant(const QLocale &l)
-    : d(Locale)
+    : d(QMetaType::QLocale)
 { v_construct<QLocale>(&d, l); }
 #if QT_CONFIG(regularexpression)
 QVariant::QVariant(const QRegularExpression &re)
-    : d(RegularExpression)
+    : d(QMetaType::QRegularExpression)
 { v_construct<QRegularExpression>(&d, re); }
 #endif // QT_CONFIG(regularexpression)
 QVariant::QVariant(const QUuid &uuid)
-    : d(Uuid)
+    : d(QMetaType::QUuid)
 { v_construct<QUuid>(&d, uuid); }
 #ifndef QT_BOOTSTRAPPED
 QVariant::QVariant(const QJsonValue &jsonValue)
@@ -914,14 +914,16 @@ QVariant::QVariant(const QJsonDocument &jsonDocument)
 #endif // QT_BOOTSTRAPPED
 #if QT_CONFIG(itemmodel)
 QVariant::QVariant(const QModelIndex &modelIndex)
-    : d(ModelIndex)
+    : d(QMetaType::QModelIndex)
 { v_construct<QModelIndex>(&d, modelIndex); }
 QVariant::QVariant(const QPersistentModelIndex &modelIndex)
-    : d(PersistentModelIndex)
+    : d(QMetaType::QPersistentModelIndex)
 { v_construct<QPersistentModelIndex>(&d, modelIndex); }
 #endif
 
-/*!
+/*! \fn QVariant::Type QVariant::type() const
+    \deprecated
+
     Returns the storage type of the value stored in the variant.
     Although this function is declared as returning QVariant::Type,
     the return value should be interpreted as QMetaType::Type. In
@@ -954,21 +956,15 @@ QVariant::QVariant(const QPersistentModelIndex &modelIndex)
 
     \sa userType(), metaType()
 */
-QVariant::Type QVariant::type() const
-{
-    int type = d.typeId();
-    return type >= QMetaType::User ? UserType : static_cast<Type>(type);
-}
-/*!
-    Returns the storage type of the value stored in the variant. For
-    non-user types, this is the same as type().
+
+/*! \fn int QVariant::userType() const
+    \fn int QVariant::typeId() const
+
+    Returns the storage type of the value stored in the variant. This is
+    the same as metaType().id().
 
     \sa type(), metaType()
 */
-int QVariant::userType() const
-{
-    return d.typeId();
-}
 
 /*!
     \since 6.0
@@ -1187,7 +1183,7 @@ void QVariant::load(QDataStream &s)
     qint8 is_null = false;
     if (s.version() >= QDataStream::Qt_4_2)
         s >> is_null;
-    if (typeId == QVariant::UserType) {
+    if (typeId == QMetaType::User) {
         QByteArray name;
         s >> name;
         typeId = QMetaType::fromName(name).id();
@@ -1330,28 +1326,17 @@ QDataStream& operator<<(QDataStream &s, const QVariant &p)
     return s;
 }
 
-/*!
+/*! \fn QDataStream& operator>>(QDataStream &s, QVariant::Type &p)
+    \deprecated
+
     Reads a variant type \a p in enum representation from the stream \a s.
 */
-QDataStream& operator>>(QDataStream &s, QVariant::Type &p)
-{
-    quint32 u;
-    s >> u;
-    p = (QVariant::Type)u;
 
-    return s;
-}
+/*! \fn QDataStream& operator<<(QDataStream &s, const QVariant::Type p)
+    \deprecated
 
-/*!
     Writes a variant type \a p to the stream \a s.
 */
-QDataStream& operator<<(QDataStream &s, const QVariant::Type p)
-{
-    s << static_cast<quint32>(p);
-
-    return s;
-}
-
 #endif //QT_NO_DATASTREAM
 
 /*!
@@ -2461,6 +2446,10 @@ QDebug QVariant::qdebugHelper(QDebug dbg) const
     return dbg;
 }
 
+#if QT_DEPRECATED_SINCE(6, 0)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+
 QDebug operator<<(QDebug dbg, const QVariant::Type p)
 {
     QDebugStateSaver saver(dbg);
@@ -2470,8 +2459,11 @@ QDebug operator<<(QDebug dbg, const QVariant::Type p)
                      : "Invalid");
     return dbg;
 }
+
+QT_WARNING_POP
 #endif
 
+#endif
 
 /*! \fn template<typename T> void QVariant::setValue(T &&value)
 
diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h
index 012b5c52b6..3fe7de451e 100644
--- a/src/corelib/kernel/qvariant.h
+++ b/src/corelib/kernel/qvariant.h
@@ -99,7 +99,9 @@ inline T qvariant_cast(const QVariant &);
 class Q_CORE_EXPORT QVariant
 {
  public:
-    enum Type {
+#if QT_DEPRECATED_SINCE(6, 0)
+    enum QT_DEPRECATED_VERSION_X_6_0("Use QMetaType::Type instead.") Type
+    {
         Invalid = QMetaType::UnknownType,
         Bool = QMetaType::Bool,
         Int = QMetaType::Int,
@@ -172,10 +174,9 @@ class Q_CORE_EXPORT QVariant
         UserType = QMetaType::User,
         LastType = 0xffffffff // need this so that gcc >= 3.4 allocates 32 bits for Type
     };
-
+#endif
     QVariant() noexcept : d() {}
     ~QVariant();
-    explicit QVariant(Type type);
     explicit QVariant(QMetaType type, const void *copy = nullptr);
     QVariant(const QVariant &other);
 
@@ -241,8 +242,8 @@ class Q_CORE_EXPORT QVariant
 
     inline void swap(QVariant &other) noexcept { qSwap(d, other.d); }
 
-    Type type() const;
-    int userType() const;
+    int typeId() const { return d.typeId(); }
+    int userType() const { return d.typeId(); }
     const char *typeName() const;
     QMetaType metaType() const;
 
@@ -325,6 +326,18 @@ class Q_CORE_EXPORT QVariant
     void save(QDataStream &ds) const;
 #endif
 #if QT_DEPRECATED_SINCE(6, 0)
+    QT_WARNING_PUSH
+    QT_WARNING_DISABLE_DEPRECATED
+    QT_DEPRECATED_VERSION_X_6_0("Use the constructor taking a QMetaType instead.")
+    explicit QVariant(Type type)
+        : QVariant(QMetaType(int(type)))
+    {}
+    QT_DEPRECATED_VERSION_X_6_0("Use metaType().")
+    Type type() const
+    {
+        int type = d.typeId();
+        return type >= QMetaType::User ? UserType : static_cast<Type>(type);
+    }
     QT_DEPRECATED_VERSION_6_0
     static const char *typeToName(int typeId)
     { return QMetaType(typeId).name(); }
@@ -334,6 +347,7 @@ class Q_CORE_EXPORT QVariant
         int metaType = QMetaType::fromName(name).id();
         return metaType <= int(UserType) ? QVariant::Type(metaType) : UserType;
     }
+    QT_WARNING_POP
 #endif
 
     void *data();
@@ -567,8 +581,27 @@ inline bool QVariant::isValid() const
 #ifndef QT_NO_DATASTREAM
 Q_CORE_EXPORT QDataStream& operator>> (QDataStream& s, QVariant& p);
 Q_CORE_EXPORT QDataStream& operator<< (QDataStream& s, const QVariant& p);
-Q_CORE_EXPORT QDataStream& operator>> (QDataStream& s, QVariant::Type& p);
-Q_CORE_EXPORT QDataStream& operator<< (QDataStream& s, const QVariant::Type p);
+
+#if QT_DEPRECATED_SINCE(6, 0)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+QT_DEPRECATED_VERSION_6_0
+inline QDataStream& operator>> (QDataStream& s, QVariant::Type &p)
+{
+    quint32 u;
+    s >> u;
+    p = static_cast<QVariant::Type>(u);
+    return s;
+}
+QT_DEPRECATED_VERSION_6_0
+inline QDataStream& operator<< (QDataStream& s, const QVariant::Type p)
+{
+    s << static_cast<quint32>(p);
+    return s;
+}
+QT_WARNING_POP
+#endif
+
 #endif
 
 inline bool QVariant::isDetached() const
@@ -597,7 +630,7 @@ template<typename T> inline T qvariant_cast(const QVariant &v)
 
 template<> inline QVariant qvariant_cast<QVariant>(const QVariant &v)
 {
-    if (v.userType() == QMetaType::QVariant)
+    if (v.metaType().id() == QMetaType::QVariant)
         return *reinterpret_cast<const QVariant *>(v.constData());
     return v;
 }
@@ -605,7 +638,13 @@ template<> inline QVariant qvariant_cast<QVariant>(const QVariant &v)
 #endif
 
 #ifndef QT_NO_DEBUG_STREAM
+#if QT_DEPRECATED_SINCE(6, 0)
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_DEPRECATED
+QT_DEPRECATED_VERSION_6_0
 Q_CORE_EXPORT QDebug operator<<(QDebug, const QVariant::Type);
+QT_WARNING_POP
+#endif
 #endif
 
 namespace QtPrivate {