20 files changed, 336 insertions, 231 deletions

diff --git a/src/corelib/tools/qalgorithms.h b/src/corelib/tools/qalgorithms.h
index 14465240b4..854276d150 100644
--- a/src/corelib/tools/qalgorithms.h
+++ b/src/corelib/tools/qalgorithms.h
@@ -142,15 +142,9 @@ QT_DEPRECATED_X("Use std::count") inline void qCount(const Container &container,
 }
 
 #ifdef Q_QDOC
-template <typename T>
-LessThan qLess()
-{
-}
-
-template <typename T>
-LessThan qGreater()
-{
-}
+typedef void* LessThan;
+template <typename T> LessThan qLess();
+template <typename T> LessThan qGreater();
 #else
 template <typename T>
 class QT_DEPRECATED_X("Use std::less") qLess
diff --git a/src/corelib/tools/qbytearray.h b/src/corelib/tools/qbytearray.h
index a53d4eabd3..bf4175d67e 100644
--- a/src/corelib/tools/qbytearray.h
+++ b/src/corelib/tools/qbytearray.h
@@ -56,9 +56,9 @@
 #error qbytearray.h must be included before any header file that defines truncate
 #endif
 
-#ifdef Q_OS_MAC
+#if defined(Q_OS_MAC) || defined(Q_QDOC)
 Q_FORWARD_DECLARE_CF_TYPE(CFData);
-#  ifdef __OBJC__
+#  if defined(__OBJC__) || defined(Q_QDOC)
 Q_FORWARD_DECLARE_OBJC_CLASS(NSData);
 #  endif
 #endif
diff --git a/src/corelib/tools/qbytearraylist.h b/src/corelib/tools/qbytearraylist.h
index bc8b08b380..501bb2e0d5 100644
--- a/src/corelib/tools/qbytearraylist.h
+++ b/src/corelib/tools/qbytearraylist.h
@@ -50,11 +50,13 @@ QT_BEGIN_NAMESPACE
 
 typedef QListIterator<QByteArray> QByteArrayListIterator;
 typedef QMutableListIterator<QByteArray> QMutableByteArrayListIterator;
+#ifndef Q_QDOC
 typedef QList<QByteArray> QByteArrayList;
 
 namespace QtPrivate {
     QByteArray Q_CORE_EXPORT QByteArrayList_join(const QByteArrayList *that, const char *separator, int separatorLength);
 }
+#endif
 
 #ifdef Q_QDOC
 class QByteArrayList : public QList<QByteArray>
diff --git a/src/corelib/tools/qchar.h b/src/corelib/tools/qchar.h
index f01fbc109c..a83e5e6f98 100644
--- a/src/corelib/tools/qchar.h
+++ b/src/corelib/tools/qchar.h
@@ -578,6 +578,18 @@ Q_DECL_CONSTEXPR inline bool operator>=(QChar c1, QChar c2) Q_DECL_NOTHROW { ret
 Q_DECL_CONSTEXPR inline bool operator> (QChar c1, QChar c2) Q_DECL_NOTHROW { return  operator< (c2, c1); }
 Q_DECL_CONSTEXPR inline bool operator<=(QChar c1, QChar c2) Q_DECL_NOTHROW { return !operator< (c2, c1); }
 
+// disambiguate QChar == int (but only that, so constrain template to exactly 'int'):
+template <typename T>
+Q_DECL_DEPRECATED_X("don't compare ints to QChars, compare them to QChar::unicode() instead")
+Q_DECL_CONSTEXPR inline
+typename std::enable_if<std::is_same<typename std::remove_cv<T>::type, int>::value, bool>::type
+operator==(QChar lhs, T rhs) Q_DECL_NOEXCEPT { return lhs == QChar(rhs); }
+template <typename T>
+Q_DECL_DEPRECATED_X("don't compare ints to QChars, compare them to QChar::unicode() instead")
+Q_DECL_CONSTEXPR inline
+typename std::enable_if<std::is_same<typename std::remove_cv<T>::type, int>::value, bool>::type
+operator!=(QChar lhs, T rhs) Q_DECL_NOEXCEPT { return lhs != QChar(rhs); }
+
 #ifndef QT_NO_DATASTREAM
 Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, QChar);
 Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QChar &);
diff --git a/src/corelib/tools/qcommandlineoption.cpp b/src/corelib/tools/qcommandlineoption.cpp
index 64cabcc304..1f7f9cc33b 100644
--- a/src/corelib/tools/qcommandlineoption.cpp
+++ b/src/corelib/tools/qcommandlineoption.cpp
@@ -49,14 +49,12 @@ class QCommandLineOptionPrivate : public QSharedData
 public:
     Q_NEVER_INLINE
     explicit QCommandLineOptionPrivate(const QString &name)
-        : names(removeInvalidNames(QStringList(name))),
-          hidden(false)
+        : names(removeInvalidNames(QStringList(name)))
     { }
 
     Q_NEVER_INLINE
     explicit QCommandLineOptionPrivate(const QStringList &names)
-        : names(removeInvalidNames(names)),
-          hidden(false)
+        : names(removeInvalidNames(names))
     { }
 
     static QStringList removeInvalidNames(QStringList nameList);
@@ -74,8 +72,7 @@ public:
     //! The list of default values used for this option.
     QStringList defaultValues;
 
-    //! Show or hide in --help
-    bool hidden;
+    QCommandLineOption::Flags flags;
 };
 
 /*!
@@ -394,6 +391,7 @@ QStringList QCommandLineOption::defaultValues() const
     return d->defaultValues;
 }
 
+#if QT_DEPRECATED_SINCE(5, 8)
 /*!
     Sets whether to hide this option in the user-visible help output.
 
@@ -401,11 +399,12 @@ QStringList QCommandLineOption::defaultValues() const
     a particular option makes it internal, i.e. not listed in the help output.
 
     \since 5.6
+    \obsolete Use setFlags(QCommandLineOption::HiddenFromHelp), QCommandLineOption::HiddenFromHelp
     \sa isHidden
  */
 void QCommandLineOption::setHidden(bool hide)
 {
-    d->hidden = hide;
+    d->flags.setFlag(HiddenFromHelp, hide);
 }
 
 /*!
@@ -413,11 +412,52 @@ void QCommandLineOption::setHidden(bool hide)
     false if the option is listed.
 
     \since 5.6
-    \sa setHidden()
+    \obsolete Use flags() & QCommandLineOption::HiddenFromHelp
+    \sa setHidden(), QCommandLineOption::HiddenFromHelp
  */
 bool QCommandLineOption::isHidden() const
 {
-    return d->hidden;
+    return d->flags & HiddenFromHelp;
 }
+#endif
+
+/*!
+    Returns a set of flags that affect this command-line option.
+
+    \since 5.8
+    \sa setFlags(), QCommandLineOption::Flags
+ */
+QCommandLineOption::Flags QCommandLineOption::flags() const
+{
+    return d->flags;
+}
+
+/*!
+    Set the set of flags that affect this command-line option.
+
+    \since 5.8
+    \sa flags(), QCommandLineOption::Flags
+ */
+void QCommandLineOption::setFlags(Flags flags)
+{
+    d->flags = flags;
+}
+
+/*!
+    \enum QCommandLineOption::Flag
+
+    \value HiddenFromHelp Hide this option in the user-visible help output. All
+    options are visible by default. Setting this flag for a particular
+    option makes it internal, i.e. not listed in the help output.
+
+    \value ShortOptionStyle The option will always be understood as a short
+    option, regardless of what was set by
+    QCommandLineParser::setSingleDashWordOptionMode.
+    This allows flags such as \c{-DDEFINE=VALUE} or \c{-I/include/path} to be
+    interpreted as short flags even when the parser is in
+    QCommandLineParser::ParseAsLongOptions mode.
+
+    \sa QCommandLineOption::setFlags(), QCommandLineOption::flags()
+*/
 
 QT_END_NAMESPACE
diff --git a/src/corelib/tools/qcommandlineoption.h b/src/corelib/tools/qcommandlineoption.h
index a7747f9fb2..6ebaab3d48 100644
--- a/src/corelib/tools/qcommandlineoption.h
+++ b/src/corelib/tools/qcommandlineoption.h
@@ -50,6 +50,12 @@ class QCommandLineOptionPrivate;
 class Q_CORE_EXPORT QCommandLineOption
 {
 public:
+    enum Flag {
+        HiddenFromHelp = 0x1,
+        ShortOptionStyle = 0x2
+    };
+    Q_DECLARE_FLAGS(Flags, Flag)
+
     explicit QCommandLineOption(const QString &name);
     explicit QCommandLineOption(const QStringList &names);
     /*implicit*/ QCommandLineOption(const QString &name, const QString &description,
@@ -82,14 +88,24 @@ public:
     void setDefaultValues(const QStringList &defaultValues);
     QStringList defaultValues() const;
 
+    Flags flags() const;
+    void setFlags(Flags aflags);
+
+#if QT_DEPRECATED_SINCE(5, 8)
+    QT_DEPRECATED_X("Use setFlags() with HiddenFromHelp)")
     void setHidden(bool hidden);
+    QT_DEPRECATED_X("Use flags() and HiddenFromHelp")
     bool isHidden() const;
+#endif
+
 
 private:
     QSharedDataPointer<QCommandLineOptionPrivate> d;
 };
 
 Q_DECLARE_SHARED(QCommandLineOption)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QCommandLineOption::Flags)
+
 
 QT_END_NAMESPACE
 
diff --git a/src/corelib/tools/qcommandlineparser.cpp b/src/corelib/tools/qcommandlineparser.cpp
index 6587d900d2..c0bd132fc3 100644
--- a/src/corelib/tools/qcommandlineparser.cpp
+++ b/src/corelib/tools/qcommandlineparser.cpp
@@ -44,7 +44,7 @@
 #include <qhash.h>
 #include <qvector.h>
 #include <qdebug.h>
-#if defined(Q_OS_WIN) && !defined(QT_BOOTSTRAPPED) && !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
+#if defined(Q_OS_WIN) && !defined(QT_BOOTSTRAPPED) && !defined(Q_OS_WINRT)
 #  include <qt_windows.h>
 #endif
 #include <stdio.h>
@@ -295,7 +295,9 @@ QCommandLineParser::~QCommandLineParser()
     i.e. as the long option named \c{abc}. This is how Qt's own tools
     (uic, rcc...) have always been parsing arguments. This mode should be
     used for preserving compatibility in applications that were parsing
-    arguments in such a way.
+    arguments in such a way. There is an exception if the \c{a} option has the
+    QCommandLineOption::ShortOptionStyle flag set, in which case it is still
+    interpreted as \c{-a bc}.
 
     \sa setSingleDashWordOptionMode()
 */
@@ -530,7 +532,7 @@ QString QCommandLineParser::errorText() const
 
 enum MessageType { UsageMessage, ErrorMessage };
 
-#if defined(Q_OS_WIN) && !defined(QT_BOOTSTRAPPED) && !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
+#if defined(Q_OS_WIN) && !defined(QT_BOOTSTRAPPED) && !defined(Q_OS_WINRT)
 // Return whether to use a message box. Use handles if a console can be obtained
 // or we are run with redirected handles (for example, by QProcess).
 static inline bool displayMessageBox()
@@ -552,7 +554,7 @@ static void showParserMessage(const QString &message, MessageType type)
     else
         qCritical(qPrintable(message));
     return;
-#elif defined(Q_OS_WIN) && !defined(QT_BOOTSTRAPPED) && !defined(Q_OS_WINCE)
+#elif defined(Q_OS_WIN) && !defined(QT_BOOTSTRAPPED)
     if (displayMessageBox()) {
         const UINT flags = MB_OK | MB_TOPMOST | MB_SETFOREGROUND
             | (type == UsageMessage ? MB_ICONINFORMATION : MB_ICONERROR);
@@ -565,7 +567,7 @@ static void showParserMessage(const QString &message, MessageType type)
                     reinterpret_cast<const wchar_t *>(title.utf16()), flags);
         return;
     }
-#endif // Q_OS_WIN && !QT_BOOTSTRAPPED && !Q_OS_WINCE
+#endif // Q_OS_WIN && !QT_BOOTSTRAPPED
     fputs(qPrintable(message), type == UsageMessage ? stdout : stderr);
 }
 
@@ -762,6 +764,18 @@ bool QCommandLineParserPrivate::parse(const QStringList &args)
             }
             case QCommandLineParser::ParseAsLongOptions:
             {
+                if (argument.size() > 2) {
+                    const QString possibleShortOptionStyleName = argument.mid(1, 1);
+                    const auto shortOptionIt = nameHash.constFind(possibleShortOptionStyleName);
+                    if (shortOptionIt != nameHash.constEnd()) {
+                        const auto &arg = commandLineOptionList.at(*shortOptionIt);
+                        if (arg.flags() & QCommandLineOption::ShortOptionStyle) {
+                            registerFoundOption(possibleShortOptionStyleName);
+                            optionValuesHash[*shortOptionIt].append(argument.mid(2));
+                            break;
+                        }
+                    }
+                }
                 const QString optionName = argument.mid(1).section(assignChar, 0, 0);
                 if (registerFoundOption(optionName)) {
                     if (!parseOptionValue(optionName, argument, &argumentIterator, args.end()))
@@ -1097,7 +1111,7 @@ QString QCommandLineParserPrivate::helpText() const
     optionNameList.reserve(commandLineOptionList.size());
     int longestOptionNameString = 0;
     for (const QCommandLineOption &option : commandLineOptionList) {
-        if (option.isHidden())
+        if (option.flags() & QCommandLineOption::HiddenFromHelp)
             continue;
         const QStringList optionNames = option.names();
         QString optionNamesString;
@@ -1116,7 +1130,7 @@ QString QCommandLineParserPrivate::helpText() const
     ++longestOptionNameString;
     auto optionNameIterator = optionNameList.cbegin();
     for (const QCommandLineOption &option : commandLineOptionList) {
-        if (option.isHidden())
+        if (option.flags() & QCommandLineOption::HiddenFromHelp)
             continue;
         text += wrapText(*optionNameIterator, longestOptionNameString, option.description());
         ++optionNameIterator;
diff --git a/src/corelib/tools/qdatetime.cpp b/src/corelib/tools/qdatetime.cpp
index 7cc86eb3f1..9aba68eef3 100644
--- a/src/corelib/tools/qdatetime.cpp
+++ b/src/corelib/tools/qdatetime.cpp
@@ -57,9 +57,6 @@
 #include <time.h>
 #ifdef Q_OS_WIN
 #  include <qt_windows.h>
-#  ifdef Q_OS_WINCE
-#    include "qfunctions_wince.h"
-#  endif
 #  ifdef Q_OS_WINRT
 #    include "qfunctions_winrt.h"
 #  endif
@@ -1685,9 +1682,6 @@ QString QTime::toString(const QString& format) const
 
 bool QTime::setHMS(int h, int m, int s, int ms)
 {
-#if defined(Q_OS_WINCE)
-    startTick = NullTime;
-#endif
     if (!isValid(h,m,s,ms)) {
         mds = NullTime;                // make this invalid
         return false;
@@ -1767,10 +1761,6 @@ QTime QTime::addMSecs(int ms) const
             t.mds = (ds() + ms) % MSECS_PER_DAY;
         }
     }
-#if defined(Q_OS_WINCE)
-    if (startTick > NullTime)
-        t.startTick = (startTick + ms) % MSECS_PER_DAY;
-#endif
     return t;
 }
 
@@ -1792,13 +1782,7 @@ int QTime::msecsTo(const QTime &t) const
 {
     if (!isValid() || !t.isValid())
         return 0;
-#if defined(Q_OS_WINCE)
-    // GetLocalTime() for Windows CE has no milliseconds resolution
-    if (t.startTick > NullTime && startTick > NullTime)
-        return t.startTick - startTick;
-    else
-#endif
-        return t.ds() - ds();
+    return t.ds() - ds();
 }
 
 
@@ -2140,10 +2124,7 @@ int QTime::elapsed() const
 // Calls the platform variant of tzset
 static void qt_tzset()
 {
-#if defined(Q_OS_WINCE)
-    // WinCE doesn't use tzset
-    return;
-#elif defined(Q_OS_WIN)
+#if defined(Q_OS_WIN)
     _tzset();
 #else
     tzset();
@@ -2157,12 +2138,7 @@ static void qt_tzset()
 // Relies on tzset, mktime, or localtime having been called to populate timezone
 static int qt_timezone()
 {
-#if defined(Q_OS_WINCE)
-        TIME_ZONE_INFORMATION tzi;
-        GetTimeZoneInformation(&tzi);
-        // Expressed in minutes, convert to seconds
-        return (tzi.Bias + tzi.StandardBias) * 60;
-#elif defined(_MSC_VER) && _MSC_VER >= 1400
+#if defined(_MSC_VER)
         long offset;
         _get_timezone(&offset);
         return offset;
@@ -2191,16 +2167,6 @@ static int qt_timezone()
 // Returns the tzname, assume tzset has been called already
 static QString qt_tzname(QDateTimePrivate::DaylightStatus daylightStatus)
 {
-#if defined(Q_OS_WINCE)
-    TIME_ZONE_INFORMATION tzi;
-    DWORD res = GetTimeZoneInformation(&tzi);
-    if (res == TIME_ZONE_ID_UNKNOWN)
-        return QString();
-    else if (daylightStatus == QDateTimePrivate::DaylightTime)
-        return QString::fromWCharArray(tzi.DaylightName);
-    else
-        return QString::fromWCharArray(tzi.StandardName);
-#else
     int isDst = (daylightStatus == QDateTimePrivate::DaylightTime) ? 1 : 0;
 #if defined(_MSC_VER) && _MSC_VER >= 1400
     size_t s = 0;
@@ -2211,7 +2177,6 @@ static QString qt_tzname(QDateTimePrivate::DaylightStatus daylightStatus)
 #else
     return QString::fromLocal8Bit(tzname[isDst]);
 #endif // Q_OS_WIN
-#endif // Q_OS_WINCE
 }
 
 // Calls the platform variant of mktime for the given date, time and daylightStatus,
@@ -2226,48 +2191,6 @@ static qint64 qt_mktime(QDate *date, QTime *time, QDateTimePrivate::DaylightStat
     int yy, mm, dd;
     date->getDate(&yy, &mm, &dd);
 
-#if defined(Q_OS_WINCE)
-    // WinCE doesn't provide standard C library time functions
-    SYSTEMTIME st;
-    memset(&st, 0, sizeof(SYSTEMTIME));
-    st.wSecond = time->second();
-    st.wMinute = time->minute();
-    st.wHour = time->hour();
-    st.wDay = dd;
-    st.wMonth = mm;
-    st.wYear = yy;
-    FILETIME lft;
-    bool valid = SystemTimeToFileTime(&st, &lft);
-    FILETIME ft;
-    if (valid)
-        valid = LocalFileTimeToFileTime(&lft, &ft);
-    const time_t secsSinceEpoch = ftToTime_t(ft);
-    const time_t localSecs = ftToTime_t(lft);
-    TIME_ZONE_INFORMATION tzi;
-    GetTimeZoneInformation(&tzi);
-    bool isDaylight = false;
-    // Check for overflow
-    qint64 localDiff = qAbs(localSecs - secsSinceEpoch);
-    int daylightOffset = qAbs(tzi.Bias + tzi.DaylightBias) * 60;
-    if (localDiff > daylightOffset)
-        valid = false;
-    else
-        isDaylight = (localDiff == daylightOffset);
-    if (daylightStatus) {
-        if (isDaylight)
-            *daylightStatus = QDateTimePrivate::DaylightTime;
-        else
-            *daylightStatus = QDateTimePrivate::StandardTime;
-    }
-    if (abbreviation) {
-        if (isDaylight)
-            *abbreviation = QString::fromWCharArray(tzi.DaylightName);
-        else
-            *abbreviation = QString::fromWCharArray(tzi.StandardName);
-    }
-    if (ok)
-        *ok = valid;
-#else
     // All other platforms provide standard C library time functions
     tm local;
     memset(&local, 0, sizeof(local)); // tm_[wy]day plus any non-standard fields
@@ -2329,7 +2252,6 @@ static qint64 qt_mktime(QDate *date, QTime *time, QDateTimePrivate::DaylightStat
         if (ok)
             *ok = false;
     }
-#endif // Q_OS_WINCE
 
     return ((qint64)secsSinceEpoch * 1000) + msec;
 }
@@ -2345,23 +2267,7 @@ static bool qt_localtime(qint64 msecsSinceEpoch, QDate *localDate, QTime *localT
     tm local;
     bool valid = false;
 
-#if defined(Q_OS_WINCE)
-    FILETIME utcTime = time_tToFt(secsSinceEpoch);
-    FILETIME resultTime;
-    valid = FileTimeToLocalFileTime(&utcTime , &resultTime);
-    SYSTEMTIME sysTime;
-    if (valid)
-        valid = FileTimeToSystemTime(&resultTime , &sysTime);
-
-    if (valid) {
-        local.tm_sec = sysTime.wSecond;
-        local.tm_min = sysTime.wMinute;
-        local.tm_hour = sysTime.wHour;
-        local.tm_mday = sysTime.wDay;
-        local.tm_mon = sysTime.wMonth - 1;
-        local.tm_year = sysTime.wYear - 1900;
-    }
-#elif !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
     // localtime() is required to work as if tzset() was called before it.
     // localtime_r() does not have this requirement, so make an explicit call.
     qt_tzset();
@@ -4109,9 +4015,6 @@ QTime QTime::currentTime()
     memset(&st, 0, sizeof(SYSTEMTIME));
     GetLocalTime(&st);
     ct.setHMS(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
-#if defined(Q_OS_WINCE)
-    ct.startTick = GetTickCount() % MSECS_PER_DAY;
-#endif
     return ct;
 }
 
diff --git a/src/corelib/tools/qdatetime.h b/src/corelib/tools/qdatetime.h
index ee3be5553b..a9271ef177 100644
--- a/src/corelib/tools/qdatetime.h
+++ b/src/corelib/tools/qdatetime.h
@@ -46,9 +46,9 @@
 
 #include <limits>
 
-#ifdef Q_OS_MAC
+#if defined(Q_OS_MAC) || defined(Q_QDOC)
 Q_FORWARD_DECLARE_CF_TYPE(CFDate);
-#  ifdef __OBJC__
+#  if defined(__OBJC__) || defined(Q_QDOC)
 Q_FORWARD_DECLARE_OBJC_CLASS(NSDate);
 #  endif
 #endif
@@ -148,15 +148,9 @@ Q_DECLARE_TYPEINFO(QDate, Q_MOVABLE_TYPE);
 class Q_CORE_EXPORT QTime
 {
     explicit Q_DECL_CONSTEXPR QTime(int ms) : mds(ms)
-#if defined(Q_OS_WINCE)
-        , startTick(NullTime)
-#endif
     {}
 public:
     Q_DECL_CONSTEXPR QTime(): mds(NullTime)
-#if defined(Q_OS_WINCE)
-        , startTick(NullTime)
-#endif
     {}
     QTime(int h, int m, int s = 0, int ms = 0);
 
@@ -202,9 +196,6 @@ private:
     enum TimeFlag { NullTime = -1 };
     Q_DECL_CONSTEXPR inline int ds() const { return mds == -1 ? 0 : mds; }
     int mds;
-#if defined(Q_OS_WINCE)
-    int startTick;
-#endif
 
     friend class QDateTime;
     friend class QDateTimePrivate;
diff --git a/src/corelib/tools/qelapsedtimer_win.cpp b/src/corelib/tools/qelapsedtimer_win.cpp
index 734aaf80f2..532d61d504 100644
--- a/src/corelib/tools/qelapsedtimer_win.cpp
+++ b/src/corelib/tools/qelapsedtimer_win.cpp
@@ -58,13 +58,13 @@ static void resolveLibs()
     if (done)
         return;
 
-#if !defined(Q_OS_WINRT) && !defined(Q_OS_WINCE)
+#if !defined(Q_OS_WINRT)
     // try to get GetTickCount64 from the system
     HMODULE kernel32 = GetModuleHandleW(L"kernel32");
     if (!kernel32)
         return;
     ptrGetTickCount64 = (PtrGetTickCount64)GetProcAddress(kernel32, "GetTickCount64");
-#endif // !Q_OS_WINRT && !Q_OS_WINCE
+#endif // !Q_OS_WINRT
 
     // Retrieve the number of high-resolution performance counter ticks per second
     LARGE_INTEGER frequency;
diff --git a/src/corelib/tools/qlist.h b/src/corelib/tools/qlist.h
index 5509c3adce..8149238a50 100644
--- a/src/corelib/tools/qlist.h
+++ b/src/corelib/tools/qlist.h
@@ -118,7 +118,10 @@ struct Q_CORE_EXPORT QListData {
 };
 
 template <typename T>
-class QList : public QListSpecialMethods<T>
+class QList
+#ifndef Q_QDOC
+    : public QListSpecialMethods<T>
+#endif
 {
 public:
     struct MemoryLayout
diff --git a/src/corelib/tools/qlocale_win.cpp b/src/corelib/tools/qlocale_win.cpp
index 88bfada515..b4598af45a 100644
--- a/src/corelib/tools/qlocale_win.cpp
+++ b/src/corelib/tools/qlocale_win.cpp
@@ -1161,19 +1161,16 @@ static QByteArray getWinLocaleName(LPWSTR id)
         }
     }
 
-#if defined(Q_OS_WINCE)
-    result = winLangCodeToIsoName(id != LOCALE_USER_DEFAULT ? id : GetUserDefaultLCID());
-#else // !Q_OS_WINCE
-#  ifndef Q_OS_WINRT
+#ifndef Q_OS_WINRT
     if (id == LOCALE_USER_DEFAULT)
         id = GetUserDefaultLCID();
-#  else // !Q_OS_WINRT
+#else // !Q_OS_WINRT
     WCHAR lcName[LOCALE_NAME_MAX_LENGTH];
     if (QString::fromWCharArray(id) == QString::fromWCharArray(LOCALE_NAME_USER_DEFAULT)) {
         GetUserDefaultLocaleName(lcName, LOCALE_NAME_MAX_LENGTH);
         id = lcName;
     }
-#  endif // Q_OS_WINRT
+#endif // Q_OS_WINRT
     QString resultuage = winIso639LangName(id);
     QString country = winIso3116CtryName(id);
     result = resultuage.toLatin1();
@@ -1181,7 +1178,6 @@ static QByteArray getWinLocaleName(LPWSTR id)
         result += '_';
         result += country.toLatin1();
     }
-#endif // !Q_OS_WINCE
 
     return result;
 }
diff --git a/src/corelib/tools/qsharedpointer.h b/src/corelib/tools/qsharedpointer.h
index 901862e7a2..6742a66939 100644
--- a/src/corelib/tools/qsharedpointer.h
+++ b/src/corelib/tools/qsharedpointer.h
@@ -68,6 +68,7 @@ public:
     // constructors
     QSharedPointer();
     explicit QSharedPointer(T *ptr);
+    template<typename Deleter>
     QSharedPointer(T *ptr, Deleter d);
     QSharedPointer(const QSharedPointer<T> &other);
     QSharedPointer(const QWeakPointer<T> &other);
diff --git a/src/corelib/tools/qsimd.cpp b/src/corelib/tools/qsimd.cpp
index 9037442d9d..698189f9c6 100644
--- a/src/corelib/tools/qsimd.cpp
+++ b/src/corelib/tools/qsimd.cpp
@@ -48,16 +48,8 @@
 #endif
 
 #if defined(Q_OS_WIN)
-#  if defined(Q_OS_WINCE)
-#    include <qt_windows.h>
-#    if _WIN32_WCE < 0x800
-#      include <cmnintrin.h>
-#    endif
-#  endif
 #  if !defined(Q_CC_GNU)
-#    ifndef Q_OS_WINCE
-#      include <intrin.h>
-#    endif
+#    include <intrin.h>
 #  endif
 #elif defined(Q_OS_LINUX) && (defined(Q_PROCESSOR_ARM) || defined(Q_PROCESSOR_MIPS_32))
 #include "private/qcore_unix_p.h"
@@ -93,25 +85,6 @@ static inline uint detectProcessorFeatures()
 {
     return 0;
 }
-#elif defined (Q_OS_WINCE)
-static inline quint64 detectProcessorFeatures()
-{
-    quint64 features = 0;
-
-#if defined (ARM)
-#  ifdef PF_ARM_NEON
-    if (IsProcessorFeaturePresent(PF_ARM_NEON))
-        features |= Q_UINT64_C(1) << CpuFeatureNEON;
-#  endif
-#elif defined(_X86_)
-    if (IsProcessorFeaturePresent(PF_XMMI64_INSTRUCTIONS_AVAILABLE))
-        features |= Q_UINT64_C(1) << CpuFeatureSSE2;
-    if (IsProcessorFeaturePresent(PF_SSE3_INSTRUCTIONS_AVAILABLE))
-        features |= Q_UINT64_C(1) << CpuFeatureSSE3;
-#endif
-    return features;
-}
-
 #elif defined(Q_PROCESSOR_ARM)
 static inline quint64 detectProcessorFeatures()
 {
diff --git a/src/corelib/tools/qsimd_p.h b/src/corelib/tools/qsimd_p.h
index a4fe8e67f8..48ef686bbd 100644
--- a/src/corelib/tools/qsimd_p.h
+++ b/src/corelib/tools/qsimd_p.h
@@ -139,7 +139,7 @@
  *      }
  */
 
-#if defined(__MINGW64_VERSION_MAJOR) || (defined(Q_CC_MSVC) && !defined(Q_OS_WINCE))
+#if defined(__MINGW64_VERSION_MAJOR) || defined(Q_CC_MSVC)
 #include <intrin.h>
 #endif
 
@@ -483,7 +483,7 @@ static Q_ALWAYS_INLINE unsigned _bit_scan_forward(unsigned val)
 }
 #elif defined(Q_PROCESSOR_X86)
 // Bit scan functions for x86
-#  if defined(Q_CC_MSVC) && !defined(Q_OS_WINCE)
+#  if defined(Q_CC_MSVC)
 // MSVC calls it _BitScanReverse and returns the carry flag, which we don't need
 static __forceinline unsigned long _bit_scan_reverse(uint val)
 {
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 5cbad2554c..accdb83608 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -81,9 +81,6 @@
 
 #ifdef Q_OS_WIN
 #  include <qt_windows.h>
-#  ifdef Q_OS_WINCE
-#    include <winnls.h>
-#  endif
 #endif
 
 #ifdef truncate
@@ -5518,7 +5515,7 @@ int QString::localeAwareCompare(const QString &other) const
     return localeAwareCompare_helper(constData(), length(), other.constData(), other.length());
 }
 
-#if defined(QT_USE_ICU) && !defined(Q_OS_WIN32) && !defined(Q_OS_WINCE) && !defined (Q_OS_MAC)
+#if defined(QT_USE_ICU) && !defined(Q_OS_WIN32) && !defined(Q_OS_DARWIN)
 Q_GLOBAL_STATIC(QThreadStorage<QCollator>, defaultCollator)
 #endif
 
@@ -5533,12 +5530,12 @@ int QString::localeAwareCompare_helper(const QChar *data1, int length1,
     if (length1 == 0 || length2 == 0)
         return ucstrcmp(data1, length1, data2, length2);
 
-#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
-#ifndef Q_OS_WINRT
+#if defined(Q_OS_WIN)
+#  ifndef Q_OS_WINRT
     int res = CompareString(GetUserDefaultLCID(), 0, (wchar_t*)data1, length1, (wchar_t*)data2, length2);
-#else
+#  else
     int res = CompareStringEx(LOCALE_NAME_USER_DEFAULT, 0, (LPCWSTR)data1, length1, (LPCWSTR)data2, length2, NULL, NULL, 0);
-#endif
+#  endif
 
     switch (res) {
     case CSTR_LESS_THAN:
@@ -8324,6 +8321,78 @@ QString &QString::setRawData(const QChar *unicode, int size)
     Returns the size of the Latin-1 string stored in this object.
 */
 
+/*! \fn QLatin1Char QLatin1String::at(int pos) const
+    \since 5.8
+
+    Returns the character at position \a pos in this object.
+
+    \note This function performs no error checking.
+    The behavior is undefined when \a pos < 0 or \a pos ≥ size().
+
+    \sa operator[]()
+*/
+
+/*! \fn QLatin1Char QLatin1String::operator[](int pos) const
+    \since 5.8
+
+    Returns the character at position \a pos in this object.
+
+    \note This function performs no error checking.
+    The behavior is undefined when \a pos < 0 or \a pos ≥ size().
+
+    \sa at()
+*/
+
+/*! \fn QLatin1String QLatin1String::mid(int start) const
+    \since 5.8
+
+    Returns the substring starting at position \a start in this object,
+    and extending to the end of the string.
+
+    \note This function performs no error checking.
+    The behavior is undefined when \a start < 0 or \a start > size().
+
+    \sa left(), right()
+*/
+
+/*! \fn QLatin1String QLatin1String::mid(int start, int length) const
+    \since 5.8
+    \overload
+
+    Returns the substring of length \a length starting at position
+    \a start in this object.
+
+    \note This function performs no error checking.
+    The behavior is undefined when \a start < 0, \length < 0,
+    or \a start + \a length > size().
+
+    \sa left(), right()
+*/
+
+/*! \fn QLatin1String QLatin1String::left(int length) const
+    \since 5.8
+
+    Returns the substring of length \a length starting at position
+    0 in this object.
+
+    \note This function performs no error checking.
+    The behavior is undefined when \length < 0 or \a length > size().
+
+    \sa mid(), right()
+*/
+
+/*! \fn QLatin1String QLatin1String::right(int length) const
+    \since 5.8
+
+    Returns the substring of length \a length starting at position
+    size() - \a length in this object.
+
+    \note This function performs no error checking.
+    The behavior is undefined when \length < 0 or \a length > size().
+
+    \sa mid(), left()
+*/
+
 /*! \fn bool QLatin1String::operator==(const QString &other) const
 
     Returns \c true if this string is equal to string \a other;
diff --git a/src/corelib/tools/qstring.h b/src/corelib/tools/qstring.h
index 793a859228..71d6e6c762 100644
--- a/src/corelib/tools/qstring.h
+++ b/src/corelib/tools/qstring.h
@@ -68,9 +68,9 @@ namespace std
 #error qstring.h must be included before any header file that defines truncate
 #endif
 
-#ifdef Q_OS_MAC
+#if defined(Q_OS_MAC) || defined(Q_QDOC)
 Q_FORWARD_DECLARE_CF_TYPE(CFString);
-#  ifdef __OBJC__
+#  if defined(__OBJC__) || defined(Q_QDOC)
 Q_FORWARD_DECLARE_OBJC_CLASS(NSString);
 #  endif
 #endif
@@ -99,6 +99,18 @@ public:
     Q_DECL_CONSTEXPR int size() const Q_DECL_NOTHROW { return m_size; }
     Q_DECL_CONSTEXPR const char *data() const Q_DECL_NOTHROW { return m_data; }
 
+    Q_DECL_CONSTEXPR QLatin1Char at(int i) const { return QLatin1Char(m_data[i]); }
+    Q_DECL_CONSTEXPR QLatin1Char operator[](int i) const { return at(i); }
+
+    Q_DECL_CONSTEXPR QLatin1String mid(int pos) const
+    { return QLatin1String(m_data + pos, m_size - pos); }
+    Q_DECL_CONSTEXPR QLatin1String mid(int pos, int n) const
+    { return QLatin1String(m_data + pos, n); }
+    Q_DECL_CONSTEXPR QLatin1String left(int n) const
+    { return QLatin1String(m_data, n); }
+    Q_DECL_CONSTEXPR QLatin1String right(int n) const
+    { return QLatin1String(m_data + m_size - n, n); }
+
     inline bool operator==(const QString &s) const Q_DECL_NOTHROW;
     inline bool operator!=(const QString &s) const Q_DECL_NOTHROW;
     inline bool operator>(const QString &s) const Q_DECL_NOTHROW;
@@ -593,7 +605,7 @@ public:
                               Qt::CaseSensitivity cs = Qt::CaseSensitive) Q_DECL_NOTHROW
     { return -s2.compare(s1, cs); }
 
-    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const Q_DECL_NOTHROW;
+    inline int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const Q_DECL_NOTHROW;
     static int compare(const QString &s1, const QStringRef &s2,
                        Qt::CaseSensitivity = Qt::CaseSensitive) Q_DECL_NOTHROW;
 
@@ -802,6 +814,16 @@ private:
 
     Data *d;
 
+    friend inline bool operator==(QChar, const QString &) Q_DECL_NOTHROW;
+    friend inline bool operator< (QChar, const QString &) Q_DECL_NOTHROW;
+    friend inline bool operator> (QChar, const QString &) Q_DECL_NOTHROW;
+    friend inline bool operator==(QChar, const QStringRef &) Q_DECL_NOTHROW;
+    friend inline bool operator< (QChar, const QStringRef &) Q_DECL_NOTHROW;
+    friend inline bool operator> (QChar, const QStringRef &) Q_DECL_NOTHROW;
+    friend inline bool operator==(QChar, QLatin1String) Q_DECL_NOTHROW;
+    friend inline bool operator< (QChar, QLatin1String) Q_DECL_NOTHROW;
+    friend inline bool operator> (QChar, QLatin1String) Q_DECL_NOTHROW;
+
     void reallocData(uint alloc, bool grow = false);
     void expand(int i);
     QString multiArg(int numArgs, const QString **args) const;
@@ -1518,24 +1540,10 @@ inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize)
 inline QStringRef::QStringRef(const QString *aString)
     :m_string(aString), m_position(0), m_size(aString?aString->size() : 0){}
 
+// QStringRef <> QStringRef
 Q_CORE_EXPORT bool operator==(const QStringRef &s1, const QStringRef &s2) Q_DECL_NOTHROW;
 inline bool operator!=(const QStringRef &s1, const QStringRef &s2) Q_DECL_NOTHROW
 { return !(s1 == s2); }
-Q_CORE_EXPORT bool operator==(const QString &s1, const QStringRef &s2) Q_DECL_NOTHROW;
-inline bool operator!=(const QString &s1, const QStringRef &s2) Q_DECL_NOTHROW
-{ return !(s1 == s2); }
-inline bool operator==(const QStringRef &s1, const QString &s2) Q_DECL_NOTHROW
-{ return s2 == s1; }
-inline bool operator!=(const QStringRef &s1, const QString &s2) Q_DECL_NOTHROW
-{ return s2 != s1; }
-Q_CORE_EXPORT bool operator==(QLatin1String s1, const QStringRef &s2) Q_DECL_NOTHROW;
-inline bool operator!=(QLatin1String s1, const QStringRef &s2) Q_DECL_NOTHROW
-{ return !(s1 == s2); }
-inline bool operator==(const QStringRef &s1, QLatin1String s2) Q_DECL_NOTHROW
-{ return s2 == s1; }
-inline bool operator!=(const QStringRef &s1, QLatin1String s2) Q_DECL_NOTHROW
-{ return s2 != s1; }
-
 Q_CORE_EXPORT bool operator<(const QStringRef &s1, const QStringRef &s2) Q_DECL_NOTHROW;
 inline bool operator>(const QStringRef &s1, const QStringRef &s2) Q_DECL_NOTHROW
 { return s2 < s1; }
@@ -1544,6 +1552,110 @@ inline bool operator<=(const QStringRef &s1, const QStringRef &s2) Q_DECL_NOTHRO
 inline bool operator>=(const QStringRef &s1, const QStringRef &s2) Q_DECL_NOTHROW
 { return !(s1 < s2); }
 
+// QString <> QStringRef
+Q_CORE_EXPORT bool operator==(const QString &lhs, const QStringRef &rhs) Q_DECL_NOTHROW;
+inline bool operator!=(const QString &lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return lhs.compare(rhs) != 0; }
+inline bool operator< (const QString &lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return lhs.compare(rhs) <  0; }
+inline bool operator> (const QString &lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return lhs.compare(rhs) >  0; }
+inline bool operator<=(const QString &lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return lhs.compare(rhs) <= 0; }
+inline bool operator>=(const QString &lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return lhs.compare(rhs) >= 0; }
+
+inline bool operator==(const QStringRef &lhs, const QString &rhs) Q_DECL_NOTHROW { return rhs == lhs; }
+inline bool operator!=(const QStringRef &lhs, const QString &rhs) Q_DECL_NOTHROW { return rhs != lhs; }
+inline bool operator< (const QStringRef &lhs, const QString &rhs) Q_DECL_NOTHROW { return rhs >  lhs; }
+inline bool operator> (const QStringRef &lhs, const QString &rhs) Q_DECL_NOTHROW { return rhs <  lhs; }
+inline bool operator<=(const QStringRef &lhs, const QString &rhs) Q_DECL_NOTHROW { return rhs >= lhs; }
+inline bool operator>=(const QStringRef &lhs, const QString &rhs) Q_DECL_NOTHROW { return rhs <= lhs; }
+
+inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const Q_DECL_NOTHROW
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs) Q_DECL_NOTHROW
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const Q_DECL_NOTHROW
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const Q_DECL_NOTHROW
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const Q_DECL_NOTHROW
+{ return QString::compare_helper(constData(), length(), s, cs); }
+inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs) Q_DECL_NOTHROW
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs) Q_DECL_NOTHROW
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs) Q_DECL_NOTHROW
+{ return QString::compare_helper(s1.constData(), s1.length(), s2, cs); }
+
+// QLatin1String <> QStringRef
+Q_CORE_EXPORT bool operator==(QLatin1String lhs, const QStringRef &rhs) Q_DECL_NOTHROW;
+inline bool operator!=(QLatin1String lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return rhs.compare(lhs) != 0; }
+inline bool operator< (QLatin1String lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return rhs.compare(lhs) >  0; }
+inline bool operator> (QLatin1String lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return rhs.compare(lhs) <  0; }
+inline bool operator<=(QLatin1String lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return rhs.compare(lhs) >= 0; }
+inline bool operator>=(QLatin1String lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return rhs.compare(lhs) <= 0; }
+
+inline bool operator==(const QStringRef &lhs, QLatin1String rhs) Q_DECL_NOTHROW { return rhs == lhs; }
+inline bool operator!=(const QStringRef &lhs, QLatin1String rhs) Q_DECL_NOTHROW { return rhs != lhs; }
+inline bool operator< (const QStringRef &lhs, QLatin1String rhs) Q_DECL_NOTHROW { return rhs >  lhs; }
+inline bool operator> (const QStringRef &lhs, QLatin1String rhs) Q_DECL_NOTHROW { return rhs <  lhs; }
+inline bool operator<=(const QStringRef &lhs, QLatin1String rhs) Q_DECL_NOTHROW { return rhs >= lhs; }
+inline bool operator>=(const QStringRef &lhs, QLatin1String rhs) Q_DECL_NOTHROW { return rhs <= lhs; }
+
+// QChar <> QString
+inline bool operator==(QChar lhs, const QString &rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) == 0; }
+inline bool operator< (QChar lhs, const QString &rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) <  0; }
+inline bool operator> (QChar lhs, const QString &rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) >  0; }
+
+inline bool operator!=(QChar lhs, const QString &rhs) Q_DECL_NOTHROW { return !(lhs == rhs); }
+inline bool operator<=(QChar lhs, const QString &rhs) Q_DECL_NOTHROW { return !(lhs >  rhs); }
+inline bool operator>=(QChar lhs, const QString &rhs) Q_DECL_NOTHROW { return !(lhs <  rhs); }
+
+inline bool operator==(const QString &lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs == lhs; }
+inline bool operator!=(const QString &lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs == lhs); }
+inline bool operator< (const QString &lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs >  lhs; }
+inline bool operator> (const QString &lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs <  lhs; }
+inline bool operator<=(const QString &lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs <  lhs); }
+inline bool operator>=(const QString &lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs >  lhs); }
+
+// QChar <> QStringRef
+inline bool operator==(QChar lhs, const QStringRef &rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) == 0; }
+inline bool operator< (QChar lhs, const QStringRef &rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) <  0; }
+inline bool operator> (QChar lhs, const QStringRef &rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.data(), rhs.size()) >  0; }
+
+inline bool operator!=(QChar lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return !(lhs == rhs); }
+inline bool operator<=(QChar lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return !(lhs >  rhs); }
+inline bool operator>=(QChar lhs, const QStringRef &rhs) Q_DECL_NOTHROW { return !(lhs <  rhs); }
+
+inline bool operator==(const QStringRef &lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs == lhs; }
+inline bool operator!=(const QStringRef &lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs == lhs); }
+inline bool operator< (const QStringRef &lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs >  lhs; }
+inline bool operator> (const QStringRef &lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs <  lhs; }
+inline bool operator<=(const QStringRef &lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs <  lhs); }
+inline bool operator>=(const QStringRef &lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs >  lhs); }
+
+// QChar <> QLatin1String
+inline bool operator==(QChar lhs, QLatin1String rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.latin1(), rhs.size()) == 0; }
+inline bool operator< (QChar lhs, QLatin1String rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.latin1(), rhs.size()) <  0; }
+inline bool operator> (QChar lhs, QLatin1String rhs) Q_DECL_NOTHROW
+{ return QString::compare_helper(&lhs, 1, rhs.latin1(), rhs.size()) >  0; }
+
+inline bool operator!=(QChar lhs, QLatin1String rhs) Q_DECL_NOTHROW { return !(lhs == rhs); }
+inline bool operator<=(QChar lhs, QLatin1String rhs) Q_DECL_NOTHROW { return !(lhs >  rhs); }
+inline bool operator>=(QChar lhs, QLatin1String rhs) Q_DECL_NOTHROW { return !(lhs <  rhs); }
+
+inline bool operator==(QLatin1String lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs == lhs; }
+inline bool operator!=(QLatin1String lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs == lhs); }
+inline bool operator< (QLatin1String lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs >  lhs; }
+inline bool operator> (QLatin1String lhs, QChar rhs) Q_DECL_NOTHROW { return   rhs <  lhs; }
+inline bool operator<=(QLatin1String lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs <  lhs); }
+inline bool operator>=(QLatin1String lhs, QChar rhs) Q_DECL_NOTHROW { return !(rhs >  lhs); }
+
 #if !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)
 inline QT_ASCII_CAST_WARN bool QStringRef::operator==(const char *s) const
 { return QString::compare_helper(constData(), size(), s, -1) == 0; }
@@ -1572,23 +1684,6 @@ inline QT_ASCII_CAST_WARN bool operator>=(const char *s1, const QStringRef &s2)
 { return QString::compare_helper(s2.constData(), s2.size(), s1, -1) <= 0; }
 #endif // !defined(QT_NO_CAST_FROM_ASCII) && !defined(QT_RESTRICTED_CAST_FROM_ASCII)
 
-inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const Q_DECL_NOTHROW
-{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
-inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs) Q_DECL_NOTHROW
-{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
-inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const Q_DECL_NOTHROW
-{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
-inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const Q_DECL_NOTHROW
-{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
-inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const Q_DECL_NOTHROW
-{ return QString::compare_helper(constData(), length(), s, cs); }
-inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs) Q_DECL_NOTHROW
-{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
-inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs) Q_DECL_NOTHROW
-{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
-inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs) Q_DECL_NOTHROW
-{ return QString::compare_helper(s1.constData(), s1.length(), s2, cs); }
-
 inline int QString::localeAwareCompare(const QStringRef &s) const
 { return localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
 inline int QString::localeAwareCompare(const QString& s1, const QStringRef& s2)
diff --git a/src/corelib/tools/qstringlist.h b/src/corelib/tools/qstringlist.h
index e01f9e16e8..87f15528bf 100644
--- a/src/corelib/tools/qstringlist.h
+++ b/src/corelib/tools/qstringlist.h
@@ -149,6 +149,7 @@ public:
 
 Q_DECLARE_TYPEINFO(QStringList, Q_MOVABLE_TYPE);
 
+#ifndef Q_QDOC
 inline QStringList *QListSpecialMethods<QString>::self()
 { return static_cast<QStringList *>(this); }
 inline const QStringList *QListSpecialMethods<QString>::self() const
@@ -284,6 +285,7 @@ inline int QStringList::lastIndexOf(const QRegularExpression &rx, int from) cons
 }
 #endif // QT_NO_REGULAREXPRESSION
 #endif // QT_BOOTSTRAPPED
+#endif // Q_QDOC
 
 QT_END_NAMESPACE
 
diff --git a/src/corelib/tools/qtimezoneprivate_win.cpp b/src/corelib/tools/qtimezoneprivate_win.cpp
index 8e32db48de..4febeda537 100644
--- a/src/corelib/tools/qtimezoneprivate_win.cpp
+++ b/src/corelib/tools/qtimezoneprivate_win.cpp
@@ -383,17 +383,11 @@ static void calculateTransitionsForYear(const QWinTimeZonePrivate::QWinTransitio
 
 static QLocale::Country userCountry()
 {
-#if defined(Q_OS_WINCE)
-    // Guess that the syslem locale country is the right one to use
-    // TODO Find if WinCE has equivalent api
-    return QLocale::system().country();
-#else
     const GEOID id = GetUserGeoID(GEOCLASS_NATION);
     wchar_t code[3];
     const int size = GetGeoInfo(id, GEO_ISO2, code, 3, 0);
     return (size == 3) ? QLocalePrivate::codeToCountry(reinterpret_cast<const QChar*>(code), size)
                        : QLocale::AnyCountry;
-#endif // Q_OS_WINCE
 }
 
 // Create the system default time zone
diff --git a/src/corelib/tools/tools.pri b/src/corelib/tools/tools.pri
index 93dc71c3d8..95a7ece67c 100644
--- a/src/corelib/tools/tools.pri
+++ b/src/corelib/tools/tools.pri
@@ -152,10 +152,10 @@ else:win32 {
 } else:integrity:SOURCES += tools/qelapsedtimer_unix.cpp tools/qlocale_unix.cpp
 else:SOURCES += tools/qelapsedtimer_generic.cpp
 
-contains(QT_CONFIG, zlib) {
-    include($$PWD/../../3rdparty/zlib.pri)
-} else {
+contains(QT_CONFIG, system-zlib) {
     include($$PWD/../../3rdparty/zlib_dependency.pri)
+} else {
+    include($$PWD/../../3rdparty/zlib.pri)
 }
 
 contains(QT_CONFIG,icu) {