Teach QOperatingSystemVersion to handle new OS entries in patch releases

Adding new entries to QOperatingSystemVersion in patch releases
was previously breaking our BC guarantees because the entries are
exported, thus users cannot freely switch between different
patch-releases without a recompile if they adopted the new entries.

Move the data itself to a base class so that the entries can be
constructed inline.

Task-number: QTBUG-97808
Change-Id: Ic44f07488af8a04a3bedc10bebb740c4d68f43f3
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

4 files changed, 197 insertions, 75 deletions

diff --git a/src/corelib/global/qoperatingsystemversion.cpp b/src/corelib/global/qoperatingsystemversion.cpp
index 61f64306e2..cca503ffae 100644
--- a/src/corelib/global/qoperatingsystemversion.cpp
+++ b/src/corelib/global/qoperatingsystemversion.cpp
@@ -38,6 +38,7 @@
 ****************************************************************************/
 
 #include "qoperatingsystemversion.h"
+
 #if !defined(Q_OS_DARWIN) && !defined(Q_OS_WIN)
 #include "qoperatingsystemversion_p.h"
 #endif
@@ -145,16 +146,19 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn QOperatingSystemVersion QOperatingSystemVersion::current()
-
     Returns a QOperatingSystemVersion indicating the current OS and its version number.
 
     \sa currentType()
 */
-#if !defined(Q_OS_DARWIN) && !defined(Q_OS_WIN)
 QOperatingSystemVersion QOperatingSystemVersion::current()
 {
-    QOperatingSystemVersion version;
+    return QOperatingSystemVersionBase::current();
+}
+
+#if !defined(Q_OS_DARWIN) && !defined(Q_OS_WIN)
+QOperatingSystemVersionBase QOperatingSystemVersionBase::current()
+{
+    QOperatingSystemVersionBase version;
     version.m_os = currentType();
 #ifdef Q_OS_ANDROID
 #ifndef QT_BOOTSTRAPPED
@@ -231,8 +235,8 @@ static inline int compareVersionComponents(int lhs, int rhs)
     return lhs >= 0 && rhs >= 0 ? lhs - rhs : 0;
 }
 
-int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1,
-                                     const QOperatingSystemVersion &v2)
+int QOperatingSystemVersionBase::compare(QOperatingSystemVersionBase v1,
+                                         QOperatingSystemVersionBase v2)
 {
     if (v1.m_major == v2.m_major) {
         if (v1.m_minor == v2.m_minor) {
@@ -243,6 +247,12 @@ int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1,
     return compareVersionComponents(v1.m_major, v2.m_major);
 }
 
+int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1,
+                                     const QOperatingSystemVersion &v2)
+{
+    return QOperatingSystemVersionBase::compare(v1, v2);
+}
+
 /*!
     \fn QVersionNumber QOperatingSystemVersion::version() const
 
@@ -331,30 +341,35 @@ int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1,
 */
 QString QOperatingSystemVersion::name() const
 {
-    switch (type()) {
-    case QOperatingSystemVersion::Windows:
+    return QOperatingSystemVersionBase::name();
+}
+
+QString QOperatingSystemVersionBase::name(QOperatingSystemVersionBase osversion)
+{
+    switch (osversion.type()) {
+    case QOperatingSystemVersionBase::Windows:
         return QStringLiteral("Windows");
-    case QOperatingSystemVersion::MacOS: {
-        if (majorVersion() < 10)
+    case QOperatingSystemVersionBase::MacOS: {
+        if (osversion.majorVersion() < 10)
             return QStringLiteral("Mac OS");
-        if (majorVersion() == 10 && minorVersion() < 8)
+        if (osversion.majorVersion() == 10 && osversion.minorVersion() < 8)
             return QStringLiteral("Mac OS X");
-        if (majorVersion() == 10 && minorVersion() < 12)
+        if (osversion.majorVersion() == 10 && osversion.minorVersion() < 12)
             return QStringLiteral("OS X");
         return QStringLiteral("macOS");
     }
-    case QOperatingSystemVersion::IOS: {
-        if (majorVersion() < 4)
+    case QOperatingSystemVersionBase::IOS: {
+        if (osversion.majorVersion() < 4)
             return QStringLiteral("iPhone OS");
         return QStringLiteral("iOS");
     }
-    case QOperatingSystemVersion::TvOS:
+    case QOperatingSystemVersionBase::TvOS:
         return QStringLiteral("tvOS");
-    case QOperatingSystemVersion::WatchOS:
+    case QOperatingSystemVersionBase::WatchOS:
         return QStringLiteral("watchOS");
-    case QOperatingSystemVersion::Android:
+    case QOperatingSystemVersionBase::Android:
         return QStringLiteral("Android");
-    case QOperatingSystemVersion::Unknown:
+    case QOperatingSystemVersionBase::Unknown:
     default:
         return QString();
     }
@@ -368,11 +383,13 @@ QString QOperatingSystemVersion::name() const
 */
 bool QOperatingSystemVersion::isAnyOfType(std::initializer_list<OSType> types) const
 {
-    for (const auto &t : qAsConst(types)) {
-        if (type() == t)
-            return true;
-    }
-    return false;
+    // ### Qt7: Remove this function
+    return std::find(types.begin(), types.end(), type()) != types.end();
+}
+
+bool QOperatingSystemVersionBase::isAnyOfType(std::initializer_list<OSType> types, OSType type)
+{
+    return std::find(types.begin(), types.end(), type) != types.end();
 }
 
 /*!
diff --git a/src/corelib/global/qoperatingsystemversion.h b/src/corelib/global/qoperatingsystemversion.h
index c884e0e3e8..3c87dc9966 100644
--- a/src/corelib/global/qoperatingsystemversion.h
+++ b/src/corelib/global/qoperatingsystemversion.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2021 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -47,9 +47,11 @@ QT_BEGIN_NAMESPACE
 
 class QString;
 
-class Q_CORE_EXPORT QOperatingSystemVersion
+class QOperatingSystemVersionBase
 {
 public:
+    // ### Qt 7: Keep synchronized with the copy in QOperatingSystemVersion until Qt7,
+    // then remove this comment :)
     enum OSType {
         Unknown = 0,
         Windows,
@@ -60,6 +62,102 @@ public:
         Android
     };
 
+    constexpr QOperatingSystemVersionBase(OSType osType,
+                                            int vmajor, int vminor = -1, int vmicro = -1)
+    : m_os(osType),
+        m_major(vmajor),
+        m_minor(vminor),
+        m_micro(vmicro)
+    { }
+
+    static Q_CORE_EXPORT QOperatingSystemVersionBase current();
+    static Q_CORE_EXPORT QString name(QOperatingSystemVersionBase osversion);
+    static Q_CORE_EXPORT bool isAnyOfType(std::initializer_list<OSType> types, OSType type);
+
+    static constexpr OSType currentType()
+    {
+#if defined(Q_OS_WIN)
+        return Windows;
+#elif defined(Q_OS_MACOS)
+        return MacOS;
+#elif defined(Q_OS_IOS)
+        return IOS;
+#elif defined(Q_OS_TVOS)
+        return TvOS;
+#elif defined(Q_OS_WATCHOS)
+        return WatchOS;
+#elif defined(Q_OS_ANDROID)
+        return Android;
+#else
+        return Unknown;
+#endif
+    }
+
+    inline QVersionNumber version() const { return QVersionNumber(m_major, m_minor, m_micro); }
+
+    constexpr int majorVersion() const { return m_major; }
+    constexpr int minorVersion() const { return m_minor; }
+    constexpr int microVersion() const { return m_micro; }
+
+    constexpr int segmentCount() const
+    { return m_micro >= 0 ? 3 : m_minor >= 0 ? 2 : m_major >= 0 ? 1 : 0; }
+
+    inline bool isAnyOfType(std::initializer_list<OSType> types) const
+    {
+        return QOperatingSystemVersionBase::isAnyOfType(types, type());
+    }
+    constexpr OSType type() const { return m_os; }
+    inline QString name() const { return name(*this); }
+
+    friend bool operator>(QOperatingSystemVersionBase lhs, QOperatingSystemVersionBase rhs)
+    { return lhs.type() == rhs.type() && QOperatingSystemVersionBase::compare(lhs, rhs) > 0; }
+
+    friend bool operator>=(QOperatingSystemVersionBase lhs, QOperatingSystemVersionBase rhs)
+    { return lhs.type() == rhs.type() && QOperatingSystemVersionBase::compare(lhs, rhs) >= 0; }
+
+    friend bool operator<(QOperatingSystemVersionBase lhs, QOperatingSystemVersionBase rhs)
+    { return lhs.type() == rhs.type() && QOperatingSystemVersionBase::compare(lhs, rhs) < 0; }
+
+    friend bool operator<=(QOperatingSystemVersionBase lhs, QOperatingSystemVersionBase rhs)
+    { return lhs.type() == rhs.type() && QOperatingSystemVersionBase::compare(lhs, rhs) <= 0; }
+
+protected:
+    static Q_CORE_EXPORT int compare(QOperatingSystemVersionBase v1,
+                                     QOperatingSystemVersionBase v2);
+
+    QOperatingSystemVersionBase() = default;
+private:
+
+
+    OSType m_os;
+    int m_major;
+    int m_minor;
+    int m_micro;
+};
+
+// ### Qt 7: Un-export the class, export relevant functions. Remove the enum.
+class Q_CORE_EXPORT QOperatingSystemVersion : public QOperatingSystemVersionBase
+{
+public:
+    // ### Qt7: Remove. Keep synchronized with QOperatingSystemVersionBase::OSType until then!
+#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
+    enum OSType {
+        Unknown = 0,
+        Windows,
+        MacOS,
+        IOS,
+        TvOS,
+        WatchOS,
+        Android
+    };
+#endif
+
+    // ### Qt7: remove the branch with static const variables. Then group and sort the inline ones.
+    // Since the exported variables emit symbols they cannot be cherry-picked back to patch-releases
+    // without breaking our BC promises. They must be fully inline but we cannot make that change
+    // until Qt7
+    // @note: New entries should be added after the if-def-ery until Qt 7!!
+#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
     static const QOperatingSystemVersion Windows7;
     static const QOperatingSystemVersion Windows8;
     static const QOperatingSystemVersion Windows8_1;
@@ -88,69 +186,76 @@ public:
     static const QOperatingSystemVersion AndroidPie;
     static const QOperatingSystemVersion Android10;
     static const QOperatingSystemVersion Android11;
+#else
+    static constexpr QOperatingSystemVersionBase Windows7 { QOperatingSystemVersionBase::Windows, 6, 1 };
+    static constexpr QOperatingSystemVersionBase Windows8 { QOperatingSystemVersionBase::Windows, 6, 2 };
+    static constexpr QOperatingSystemVersionBase Windows8_1 { QOperatingSystemVersionBase::Windows, 6, 3 };
+    static constexpr QOperatingSystemVersionBase Windows10 { QOperatingSystemVersionBase::Windows, 10 };
 
-    constexpr QOperatingSystemVersion(OSType osType,
-                                             int vmajor, int vminor = -1, int vmicro = -1)
-        : m_os(osType),
-          m_major(qMax(-1, vmajor)),
-          m_minor(vmajor < 0 ? -1 : qMax(-1, vminor)),
-          m_micro(vmajor < 0 || vminor < 0 ? -1 : qMax(-1, vmicro))
-    { }
+    static constexpr QOperatingSystemVersionBase OSXMavericks { QOperatingSystemVersionBase::MacOS, 10, 9 };
+    static constexpr QOperatingSystemVersionBase OSXYosemite { QOperatingSystemVersionBase::MacOS, 10, 10 };
+    static constexpr QOperatingSystemVersionBase OSXElCapitan { QOperatingSystemVersionBase::MacOS, 10, 11 };
+    static constexpr QOperatingSystemVersionBase MacOSSierra { QOperatingSystemVersionBase::MacOS, 10, 12 };
+    static constexpr QOperatingSystemVersionBase MacOSHighSierra { QOperatingSystemVersionBase::MacOS, 10, 13 };
+    static constexpr QOperatingSystemVersionBase MacOSMojave { QOperatingSystemVersionBase::MacOS, 10, 14 };
+    static constexpr QOperatingSystemVersionBase MacOSCatalina { QOperatingSystemVersionBase::MacOS, 10, 15 };
+#if QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_11_0)
+    static constexpr QOperatingSystemVersionBase MacOSBigSur = { QOperatingSystemVersionBase::MacOS, 11, 0 };
+#else // ### Qt 7: Verify the assumption
+#   error Either you are using an outdated SDK or my assumption that Qt7 would require at least 11.0 was wrong
+#endif
+
+    static constexpr QOperatingSystemVersionBase AndroidJellyBean { QOperatingSystemVersionBase::Android, 4, 1 };
+    static constexpr QOperatingSystemVersionBase AndroidJellyBean_MR1 { QOperatingSystemVersionBase::Android, 4, 2 };
+    static constexpr QOperatingSystemVersionBase AndroidJellyBean_MR2 { QOperatingSystemVersionBase::Android, 4, 3 };
+    static constexpr QOperatingSystemVersionBase AndroidKitKat { QOperatingSystemVersionBase::Android, 4, 4 };
+    static constexpr QOperatingSystemVersionBase AndroidLollipop { QOperatingSystemVersionBase::Android, 5, 0 };
+    static constexpr QOperatingSystemVersionBase AndroidLollipop_MR1 { QOperatingSystemVersionBase::Android, 5, 1 };
+    static constexpr QOperatingSystemVersionBase AndroidMarshmallow { QOperatingSystemVersionBase::Android, 6, 0 };
+    static constexpr QOperatingSystemVersionBase AndroidNougat { QOperatingSystemVersionBase::Android, 7, 0 };
+    static constexpr QOperatingSystemVersionBase AndroidNougat_MR1 { QOperatingSystemVersionBase::Android, 7, 1 };
+    static constexpr QOperatingSystemVersionBase AndroidOreo { QOperatingSystemVersionBase::Android, 8, 0 };
+    static constexpr QOperatingSystemVersionBase AndroidOreo_MR1 { QOperatingSystemVersionBase::Android, 8, 1 };
+    static constexpr QOperatingSystemVersionBase AndroidPie { QOperatingSystemVersionBase::Android, 9, 0 };
+    static constexpr QOperatingSystemVersionBase Android10 { QOperatingSystemVersionBase::Android, 10, 0 };
+    static constexpr QOperatingSystemVersionBase Android11 { QOperatingSystemVersionBase::Android, 11, 0 };
+#endif // New (static constexpr) entries go here, only cherry-pick as far back as 6.3 (QTBUG-97808):
+
+    constexpr QOperatingSystemVersion(const QOperatingSystemVersionBase &osversion)
+        : QOperatingSystemVersionBase(osversion) {}
+
+    constexpr QOperatingSystemVersion(OSType osType, int vmajor, int vminor = -1, int vmicro = -1)
+        : QOperatingSystemVersionBase(QOperatingSystemVersionBase::OSType(osType), vmajor, vminor,
+                                      vmicro)
+    {
+    }
 
     static QOperatingSystemVersion current();
 
     static constexpr OSType currentType()
     {
-#if defined(Q_OS_WIN)
-        return Windows;
-#elif defined(Q_OS_MACOS)
-        return MacOS;
-#elif defined(Q_OS_IOS)
-        return IOS;
-#elif defined(Q_OS_TVOS)
-        return TvOS;
-#elif defined(Q_OS_WATCHOS)
-        return WatchOS;
-#elif defined(Q_OS_ANDROID)
-        return Android;
-#else
-        return Unknown;
-#endif
+        return OSType(QOperatingSystemVersionBase::currentType());
     }
 
-    QVersionNumber version() const { return QVersionNumber(m_major, m_minor, m_micro); }
+    QVersionNumber version() const { return QOperatingSystemVersionBase::version(); }
 
-    constexpr int majorVersion() const { return m_major; }
-    constexpr int minorVersion() const { return m_minor; }
-    constexpr int microVersion() const { return m_micro; }
+    constexpr int majorVersion() const { return QOperatingSystemVersionBase::majorVersion(); }
+    constexpr int minorVersion() const { return QOperatingSystemVersionBase::minorVersion(); }
+    constexpr int microVersion() const { return QOperatingSystemVersionBase::microVersion(); }
 
     constexpr int segmentCount() const
-    { return m_micro >= 0 ? 3 : m_minor >= 0 ? 2 : m_major >= 0 ? 1 : 0; }
+    { return QOperatingSystemVersionBase::segmentCount(); }
 
+    constexpr OSType type() const { return OSType(QOperatingSystemVersionBase::type()); }
     bool isAnyOfType(std::initializer_list<OSType> types) const;
-    constexpr OSType type() const { return m_os; }
     QString name() const;
 
-    friend bool operator>(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)
-    { return lhs.type() == rhs.type() && QOperatingSystemVersion::compare(lhs, rhs) > 0; }
-
-    friend bool operator>=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)
-    { return lhs.type() == rhs.type() && QOperatingSystemVersion::compare(lhs, rhs) >= 0; }
-
-    friend bool operator<(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)
-    { return lhs.type() == rhs.type() && QOperatingSystemVersion::compare(lhs, rhs) < 0; }
-
-    friend bool operator<=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)
-    { return lhs.type() == rhs.type() && QOperatingSystemVersion::compare(lhs, rhs) <= 0; }
-
 private:
     QOperatingSystemVersion() = default;
-    OSType m_os;
-    int m_major;
-    int m_minor;
-    int m_micro;
 
-    static int compare(const QOperatingSystemVersion &v1, const QOperatingSystemVersion &v2);
+    // ### Qt 7: Remove. It's only here for backwards compat with previous inline calls.
+    [[maybe_unused]] static int compare(const QOperatingSystemVersion &v1,
+                                        const QOperatingSystemVersion &v2);
 };
 Q_DECLARE_TYPEINFO(QOperatingSystemVersion, Q_PRIMITIVE_TYPE);
 
diff --git a/src/corelib/global/qoperatingsystemversion_darwin.mm b/src/corelib/global/qoperatingsystemversion_darwin.mm
index d8b927ff5d..9ecc8ca7a7 100644
--- a/src/corelib/global/qoperatingsystemversion_darwin.mm
+++ b/src/corelib/global/qoperatingsystemversion_darwin.mm
@@ -42,10 +42,10 @@
 
 QT_BEGIN_NAMESPACE
 
-QOperatingSystemVersion QOperatingSystemVersion::current()
+QOperatingSystemVersionBase QOperatingSystemVersionBase::current()
 {
     NSOperatingSystemVersion osv = NSProcessInfo.processInfo.operatingSystemVersion;
-    QOperatingSystemVersion v;
+    QOperatingSystemVersionBase v;
     v.m_os = currentType();
     v.m_major = osv.majorVersion;
     v.m_minor = osv.minorVersion;
diff --git a/src/corelib/global/qoperatingsystemversion_win.cpp b/src/corelib/global/qoperatingsystemversion_win.cpp
index c052cd9c9e..9dc8c96105 100644
--- a/src/corelib/global/qoperatingsystemversion_win.cpp
+++ b/src/corelib/global/qoperatingsystemversion_win.cpp
@@ -108,10 +108,10 @@ OSVERSIONINFOEX qWindowsVersionInfo()
     return realResult;
 }
 
-QOperatingSystemVersion QOperatingSystemVersion::current()
+QOperatingSystemVersionBase QOperatingSystemVersionBase::current()
 {
-    static QOperatingSystemVersion v = [](){
-        QOperatingSystemVersion v;
+    static QOperatingSystemVersionBase v = [](){
+        QOperatingSystemVersionBase v;
         v.m_os = currentType();
         const OSVERSIONINFOEX osv = qWindowsVersionInfo();
         v.m_major = osv.dwMajorVersion;