1 files changed, 83 insertions, 90 deletions

diff --git a/src/corelib/tools/qlist.h b/src/corelib/tools/qlist.h
index 9b2a56a66a..89e0e3f380 100644
--- a/src/corelib/tools/qlist.h
+++ b/src/corelib/tools/qlist.h
@@ -1,42 +1,6 @@
-/****************************************************************************
-**
-** Copyright (C) 2020 The Qt Company Ltd.
-** Copyright (C) 2019 Intel Corporation
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtCore module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
+// Copyright (C) 2020 The Qt Company Ltd.
+// Copyright (C) 2019 Intel Corporation
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #ifndef QLIST_H
 #define QLIST_H
@@ -46,12 +10,15 @@
 #include <QtCore/qhashfunctions.h>
 #include <QtCore/qiterator.h>
 #include <QtCore/qcontainertools_impl.h>
+#include <QtCore/qnamespace.h>
 
 #include <functional>
 #include <limits>
 #include <initializer_list>
 #include <type_traits>
 
+class tst_QList;
+
 QT_BEGIN_NAMESPACE
 
 namespace QtPrivate {
@@ -111,10 +78,15 @@ class QList
     using DataPointer = QArrayDataPointer<T>;
     class DisableRValueRefs {};
 
+    friend class ::tst_QList;
+
     DataPointer d;
 
     template <typename V, typename U> friend qsizetype QtPrivate::indexOf(const QList<V> &list, const U &u, qsizetype from) noexcept;
     template <typename V, typename U> friend qsizetype QtPrivate::lastIndexOf(const QList<V> &list, const U &u, qsizetype from) noexcept;
+    // This alias prevents the QtPrivate namespace from being exposed into the docs.
+    template <typename InputIterator>
+    using if_input_iterator = QtPrivate::IfIsInputIterator<InputIterator>;
 
 public:
     using Type = T;
@@ -145,14 +117,11 @@ public:
     public:
         using difference_type = qsizetype;
         using value_type = T;
-        // libstdc++ shipped with gcc < 11 does not have a fix for defect LWG 3346
-#if __cplusplus >= 202002L && (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 11)
-        using iterator_category = std::contiguous_iterator_tag;
+#ifdef QT_COMPILER_HAS_LWG3346
+        using iterator_concept = std::contiguous_iterator_tag;
         using element_type = value_type;
-#else
-        using iterator_category = std::random_access_iterator_tag;
 #endif
-
+        using iterator_category = std::random_access_iterator_tag;
         using pointer = T *;
         using reference = T &;
 
@@ -218,13 +187,11 @@ public:
     public:
         using difference_type = qsizetype;
         using value_type = T;
-        // libstdc++ shipped with gcc < 11 does not have a fix for defect LWG 3346
-#if __cplusplus >= 202002L && (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 11)
-        using iterator_category = std::contiguous_iterator_tag;
+#ifdef QT_COMPILER_HAS_LWG3346
+        using iterator_concept = std::contiguous_iterator_tag;
         using element_type = const value_type;
-#else
-        using iterator_category = std::random_access_iterator_tag;
 #endif
+        using iterator_category = std::random_access_iterator_tag;
         using pointer = const T *;
         using reference = const T &;
 
@@ -291,6 +258,14 @@ private:
         const std::less<const T*> less = {};
         return !less(d->end(), i.i) && !less(i.i, d->begin());
     }
+
+    void verify([[maybe_unused]] qsizetype pos = 0, [[maybe_unused]] qsizetype n = 1) const
+    {
+        Q_ASSERT(pos >= 0);
+        Q_ASSERT(pos <= size());
+        Q_ASSERT(n >= 0);
+        Q_ASSERT(n <= size() - pos);
+    }
 public:
     QList(DataPointer dd) noexcept
         : d(dd)
@@ -300,20 +275,20 @@ public:
 public:
     QList() = default;
     explicit QList(qsizetype size)
-        : d(Data::allocate(size))
+        : d(size)
     {
         if (size)
             d->appendInitialize(size);
     }
     QList(qsizetype size, parameter_type t)
-        : d(Data::allocate(size))
+        : d(size)
     {
         if (size)
             d->copyAppend(size, t);
     }
 
     inline QList(std::initializer_list<T> args)
-        : d(Data::allocate(args.size()))
+        : d(qsizetype(args.size()))
     {
         if (args.size())
             d->copyAppend(args.begin(), args.end());
@@ -321,20 +296,18 @@ public:
 
     QList<T> &operator=(std::initializer_list<T> args)
     {
-        d = DataPointer(Data::allocate(args.size()));
-        if (args.size())
-            d->copyAppend(args.begin(), args.end());
-        return *this;
+        return assign(args);
     }
-    template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator> = true>
+
+    template <typename InputIterator, if_input_iterator<InputIterator> = true>
     QList(InputIterator i1, InputIterator i2)
     {
-        if constexpr (!std::is_convertible_v<typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>) {
+        if constexpr (!std::is_convertible_v<typename std::iterator_traits<InputIterator>::iterator_category, std::forward_iterator_tag>) {
             std::copy(i1, i2, std::back_inserter(*this));
         } else {
             const auto distance = std::distance(i1, i2);
             if (distance) {
-                d = DataPointer(Data::allocate(distance));
+                d = DataPointer(qsizetype(distance));
                 // appendIteratorRange can deal with contiguous iterators on its own,
                 // this is an optimization for C++17 code.
                 if constexpr (std::is_same_v<std::decay_t<InputIterator>, iterator> ||
@@ -352,11 +325,18 @@ public:
     inline explicit QList(const String &str)
     { append(str); }
 
+    QList(qsizetype size, Qt::Initialization)
+        : d(size)
+    {
+        if (size)
+            d->appendUninitialized(size);
+    }
+
     // compiler-generated special member functions are fine!
 
-    void swap(QList<T> &other) noexcept { qSwap(d, other.d); }
+    void swap(QList &other) noexcept { d.swap(other.d); }
 
-#ifndef Q_CLANG_QDOC
+#ifndef Q_QDOC
     template <typename U = T>
     QTypeTraits::compare_eq_result_container<QList, U> operator==(const QList &other) const
     {
@@ -412,7 +392,7 @@ public:
     bool operator>(const QList &other) const;
     bool operator<=(const QList &other) const;
     bool operator>=(const QList &other) const;
-#endif // Q_CLANG_QDOC
+#endif // Q_QDOC
 
     qsizetype size() const noexcept { return d->size; }
     qsizetype count() const noexcept { return size(); }
@@ -432,6 +412,12 @@ public:
         if (size > this->size())
             d->copyAppend(size - this->size(), c);
     }
+    void resizeForOverwrite(qsizetype size)
+    {
+        resize_internal(size);
+        if (size > this->size())
+            d->appendUninitialized(size);
+    }
 
     inline qsizetype capacity() const { return qsizetype(d->constAllocatedCapacity()); }
     void reserve(qsizetype size);
@@ -450,7 +436,7 @@ public:
             return;
         if (d->needsDetach()) {
             // must allocate memory
-            DataPointer detached(Data::allocate(d.allocatedCapacity()));
+            DataPointer detached(d.allocatedCapacity());
             d.swap(detached);
         } else {
             d->truncate(0);
@@ -465,7 +451,7 @@ public:
     reference operator[](qsizetype i)
     {
         Q_ASSERT_X(size_t(i) < size_t(d->size), "QList::operator[]", "index out of range");
-        detach();
+        // don't detach() here, we detach in data below:
         return data()[i];
     }
     const_reference operator[](qsizetype i) const noexcept { return at(i); }
@@ -527,6 +513,19 @@ public:
         }
     }
 
+    QList &assign(qsizetype n, parameter_type t)
+    {
+        Q_ASSERT(n >= 0);
+        return fill(t, n);
+    }
+
+    template <typename InputIterator, if_input_iterator<InputIterator> = true>
+    QList &assign(InputIterator first, InputIterator last)
+    { d.assign(first, last); return *this; }
+
+    QList &assign(std::initializer_list<T> l)
+    { return assign(l.begin(), l.end()); }
+
     template <typename ...Args>
     iterator emplace(const_iterator before, Args&&... args)
     {
@@ -585,7 +584,7 @@ public:
     template <typename AT = T>
     qsizetype count(const AT &t) const noexcept
     {
-        return qsizetype(std::count(&*cbegin(), &*cend(), t));
+        return qsizetype(std::count(data(), data() + size(), t));
     }
 
     void removeAt(qsizetype i) { remove(i); }
@@ -654,27 +653,13 @@ public:
     QList<T> mid(qsizetype pos, qsizetype len = -1) const;
 
     QList<T> first(qsizetype n) const
-    {
-        Q_ASSERT(size_t(n) <= size_t(size()));
-        return QList<T>(begin(), begin() + n);
-    }
+    { verify(0, n); return QList<T>(begin(), begin() + n); }
     QList<T> last(qsizetype n) const
-    {
-        Q_ASSERT(size_t(n) <= size_t(size()));
-        return QList<T>(end() - n, end());
-    }
+    { verify(0, n); return QList<T>(end() - n, end()); }
     QList<T> sliced(qsizetype pos) const
-    {
-        Q_ASSERT(size_t(pos) <= size_t(size()));
-        return QList<T>(begin() + pos, end());
-    }
+    { verify(pos, 0); return QList<T>(begin() + pos, end()); }
     QList<T> sliced(qsizetype pos, qsizetype n) const
-    {
-        Q_ASSERT(size_t(pos) <= size_t(size()));
-        Q_ASSERT(n >= 0);
-        Q_ASSERT(pos + n <= size());
-        return QList<T>(begin() + pos, begin() + pos + n);
-    }
+    { verify(pos, n); return QList<T>(begin() + pos, begin() + pos + n); }
 
     T value(qsizetype i) const { return value(i, T()); }
     T value(qsizetype i, parameter_type defaultValue) const;
@@ -704,14 +689,22 @@ public:
     inline reference back() { return last(); }
     inline const_reference back() const noexcept { return last(); }
     void shrink_to_fit() { squeeze(); }
+    static qsizetype max_size() noexcept
+    {
+        return Data::max_size();
+    }
 
     // comfort
     QList<T> &operator+=(const QList<T> &l) { append(l); return *this; }
     QList<T> &operator+=(QList<T> &&l) { append(std::move(l)); return *this; }
-    inline QList<T> operator+(const QList<T> &l) const
+    inline QList<T> operator+(const QList<T> &l) const &
     { QList n = *this; n += l; return n; }
-    inline QList<T> operator+(QList<T> &&l) const
+    QList<T> operator+(const QList<T> &l) &&
+    { return std::move(*this += l); }
+    inline QList<T> operator+(QList<T> &&l) const &
     { QList n = *this; n += std::move(l); return n; }
+    QList<T> operator+(QList<T> &&l) &&
+    { return std::move(*this += std::move(l)); }
     inline QList<T> &operator+=(parameter_type t)
     { append(t); return *this; }
     inline QList<T> &operator<< (parameter_type t)
@@ -770,7 +763,7 @@ void QList<T>::reserve(qsizetype asize)
         }
     }
 
-    DataPointer detached(Data::allocate(qMax(asize, size())));
+    DataPointer detached(qMax(asize, size()));
     detached->copyAppend(d->begin(), d->end());
     if (detached.d_ptr())
         detached->setFlag(Data::CapacityReserved);
@@ -784,7 +777,7 @@ inline void QList<T>::squeeze()
         return;
     if (d->needsDetach() || size() < capacity()) {
         // must allocate memory
-        DataPointer detached(Data::allocate(size()));
+        DataPointer detached(size());
         if (size()) {
             if (d.needsDetach())
                 detached->copyAppend(d.data(), d.data() + d.size);
@@ -913,7 +906,7 @@ inline QList<T> &QList<T>::fill(parameter_type t, qsizetype newSize)
         newSize = size();
     if (d->needsDetach() || newSize > capacity()) {
         // must allocate memory
-        DataPointer detached(Data::allocate(d->detachCapacity(newSize)));
+        DataPointer detached(d->detachCapacity(newSize));
         detached->copyAppend(newSize, t);
         d.swap(detached);
     } else {
@@ -995,7 +988,7 @@ inline QList<T> QList<T>::mid(qsizetype pos, qsizetype len) const
     }
 
     // Allocate memory
-    DataPointer copied(Data::allocate(l));
+    DataPointer copied(l);
     copied->copyAppend(data() + p, data() + p + l);
     return copied;
 }