5 files changed, 45 insertions, 43 deletions
diff --git a/src/corelib/itemmodels/qrangemodel_impl.h b/src/corelib/itemmodels/qrangemodel_impl.h
index f6b08099fe7..7eca3094a66 100644
--- a/src/corelib/itemmodels/qrangemodel_impl.h
+++ b/src/corelib/itemmodels/qrangemodel_impl.h
@@ -239,17 +239,15 @@ namespace QRangeModelDetails
         : std::true_type
     {};
 
-    // we use std::rotate in moveRows/Columns, which requires std::swap and the
-    // iterators to be at least a forward iterator
-    template <typename It, typename = void>
-    struct test_rotate : std::false_type {};
-
+    // we use std::rotate in moveRows/Columns, which requires the values (which
+    // might be const if we only get a const iterator) to be swappable, and the
+    // iterator type to be at least a forward iterator
     template <typename It>
-    struct test_rotate<It, std::void_t<decltype(std::swap(*std::declval<It>(),
-                                                          *std::declval<It>()))>>
-        : std::is_base_of<std::forward_iterator_tag,
-                          typename std::iterator_traits<It>::iterator_category>
-    {};
+    using test_rotate = std::conjunction<
+                            std::is_swappable<decltype(*std::declval<It>())>,
+                            std::is_base_of<std::forward_iterator_tag,
+                                            typename std::iterator_traits<It>::iterator_category>
+                        >;
 
     template <typename C, typename = void>
     struct test_splice : std::false_type {};
diff --git a/src/corelib/itemmodels/qrangemodeladapter.h b/src/corelib/itemmodels/qrangemodeladapter.h
index 2a23e01eba2..0234c402248 100644
--- a/src/corelib/itemmodels/qrangemodeladapter.h
+++ b/src/corelib/itemmodels/qrangemodeladapter.h
@@ -19,13 +19,11 @@ class QT_TECH_PREVIEW_API QRangeModelAdapter
 
 #ifdef Q_QDOC
     using range_type = Range;
-    using const_row_reference = typename std::iterator_traits<Range>::const_reference;
-    using row_reference = typename std::iterator_traits<Range>::reference;
 #else
     using range_type = QRangeModelDetails::wrapped_t<Range>;
+#endif
     using const_row_reference = typename Impl::const_row_reference;
     using row_reference = typename Impl::row_reference;
-#endif
     using range_features = typename QRangeModelDetails::range_traits<range_type>;
     using row_type = std::remove_reference_t<row_reference>;
     using row_features = QRangeModelDetails::range_traits<typename Impl::wrapped_row_type>;
@@ -78,16 +76,22 @@ class QT_TECH_PREVIEW_API QRangeModelAdapter
     template <typename C>
     using if_compatible_row_range = std::enable_if_t<is_compatible_row_range<C>, bool>;
     template <typename Data>
-    static constexpr bool is_compatible_data = true;
-        // std::is_convertible_v<Data, decltype(*std::begin(std::declval<const_row_reference>()))>;
+    static constexpr bool is_compatible_data = std::is_convertible_v<Data, data_type>;
     template <typename Data>
     using if_compatible_data = std::enable_if_t<is_compatible_data<Data>, bool>;
     template <typename C>
     static constexpr bool is_compatible_data_range = is_compatible_data<
+                                                typename QRangeModelDetails::data_type<
+                                                    typename QRangeModelDetails::row_traits<
                                                         decltype(*std::begin(std::declval<C&>()))
-                                                    >;
+                                                    >::item_type
+                                                >::type
+                                            >;
+    template <typename C>
+    using if_compatible_column_data = std::enable_if_t<is_compatible_data<C>
+                                                    || is_compatible_data_range<C>, bool>;
     template <typename C>
-    using if_compatible_data_range = std::enable_if_t<is_compatible_data_range<C>, bool>;
+    using if_compatible_column_range = std::enable_if_t<is_compatible_data_range<C>, bool>;
 
     template <typename R>
     using if_assignable_range = std::enable_if_t<std::is_assignable_v<range_type, R>, bool>;
@@ -1262,12 +1266,12 @@ public:
     decltype(auto) operator[](int row) const { return at(row); }
 
     template <typename I = Impl, if_table<I> = true, if_writable<I> = true>
-    decltype(auto) at(int row)
+    auto at(int row)
     {
         return RowReference{index(row, 0), this};
     }
     template <typename I = Impl, if_table<I> = true, if_writable<I> = true>
-    decltype(auto) operator[](int row) { return at(row); }
+    auto operator[](int row) { return at(row); }
 
     // at/operator[int, int] for table: returns value at row/column
     template <typename I = Impl, unless_list<I> = true>
@@ -1445,15 +1449,15 @@ public:
         return storage.m_model->insertColumn(before);
     }
 
-    template <typename D = row_type, typename I = Impl,
-              if_canInsertColumns<I> = true, if_compatible_data<D> = true>
+    template <typename D, typename I = Impl,
+              if_canInsertColumns<I> = true, if_compatible_column_data<D> = true>
     bool insertColumn(int before, D &&data)
     {
         return insertColumnImpl(before, storage.root(), std::forward<D>(data));
     }
 
     template <typename C, typename I = Impl,
-              if_canInsertColumns<I> = true, if_compatible_data_range<C> = true>
+              if_canInsertColumns<I> = true, if_compatible_column_range<C> = true>
     bool insertColumns(int before, C &&data)
     {
         return insertColumnsImpl(before, storage.root(), std::forward<C>(data));
diff --git a/src/corelib/itemmodels/qrangemodeladapter.qdoc b/src/corelib/itemmodels/qrangemodeladapter.qdoc
index ff595529d34..88872589299 100644
--- a/src/corelib/itemmodels/qrangemodeladapter.qdoc
+++ b/src/corelib/itemmodels/qrangemodeladapter.qdoc
@@ -277,14 +277,6 @@
 */
 
 /*!
-    \typedef QRangeModelAdapter::const_row_reference
-*/
-
-/*!
-    \typedef QRangeModelAdapter::row_reference
-*/
-
-/*!
     \typedef QRangeModelAdapter::range_type
 */
 
@@ -531,8 +523,8 @@
 */
 
 /*!
-    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I>> QRangeModelAdapter<Range, Protocol, Model>::const_row_reference QRangeModelAdapter<Range, Protocol, Model>::at(int row) const
-    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I>> QRangeModelAdapter<Range, Protocol, Model>::const_row_reference QRangeModelAdapter<Range, Protocol, Model>::operator[](int row) const
+    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I>> decltype(auto) QRangeModelAdapter<Range, Protocol, Model>::at(int row) const
+    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::unless_list<I>> decltype(auto) QRangeModelAdapter<Range, Protocol, Model>::operator[](int row) const
 
     \return a constant reference to the row at \a row, as stored in \c Range.
 
@@ -540,8 +532,8 @@
 */
 
 /*!
-    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_table<I>, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I>> QRangeModelAdapter<Range, Protocol, Model>::row_reference QRangeModelAdapter<Range, Protocol, Model>::at(int row)
-    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_table<I>, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I>> QRangeModelAdapter<Range, Protocol, Model>::row_reference QRangeModelAdapter<Range, Protocol, Model>::operator[](int row)
+    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_table<I>, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I>> auto QRangeModelAdapter<Range, Protocol, Model>::at(int row)
+    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_table<I>, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I>> auto QRangeModelAdapter<Range, Protocol, Model>::operator[](int row)
 
     \return a mutable reference to the row at \a row, as stored in \c Range.
 
@@ -597,6 +589,16 @@
 */
 
 /*!
+    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I>> decltype(auto) QRangeModelAdapter<Range, Protocol, Model>::at(QSpan<const int> path) const
+    \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I>> decltype(auto) QRangeModelAdapter<Range, Protocol, Model>::operator[](QSpan<const int> path) const
+
+    \return a constant reference to the row specified by \a path, as stored in
+    \c Range.
+
+    \constraints \c Range is a tree.
+*/
+
+/*!
     \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I>, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I>> auto QRangeModelAdapter<Range, Protocol, Model>::at(QSpan<const int> path)
     \fn template <typename Range, typename Protocol, typename Model> template <typename I, QRangeModelAdapter<Range, Protocol, Model>::if_tree<I>, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I>> auto QRangeModelAdapter<Range, Protocol, Model>::operator[](QSpan<const int> path)
 
@@ -833,7 +835,7 @@
 */
 
 /*!
-    \fn template <typename Range, typename Protocol, typename Model> template <typename D, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I>, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_data<D>> bool QRangeModelAdapter<Range, Protocol, Model>::insertColumn(int before, D &&data)
+    \fn template <typename Range, typename Protocol, typename Model> template <typename D, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I>, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_column_data<D>> bool QRangeModelAdapter<Range, Protocol, Model>::insertColumn(int before, D &&data)
     \overload
 
     Inserts a single column constructed from \a data before the column specified
@@ -861,7 +863,7 @@
 */
 
 /*!
-    \fn template <typename Range, typename Protocol, typename Model> template <typename C, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I>, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_data_range<C>> bool QRangeModelAdapter<Range, Protocol, Model>::insertColumns(int before, C &&data)
+    \fn template <typename Range, typename Protocol, typename Model> template <typename C, typename I, QRangeModelAdapter<Range, Protocol, Model>::if_canInsertColumns<I>, QRangeModelAdapter<Range, Protocol, Model>::if_compatible_column_range<C>> bool QRangeModelAdapter<Range, Protocol, Model>::insertColumns(int before, C &&data)
 
     Inserts columns constructed from the elements in \a data before the column
     specified by \a before into all rows, and returns whether the insertion was
diff --git a/src/corelib/thread/qreadwritelock.cpp b/src/corelib/thread/qreadwritelock.cpp
index 96e35dcb965..2a1af2315ca 100644
--- a/src/corelib/thread/qreadwritelock.cpp
+++ b/src/corelib/thread/qreadwritelock.cpp
@@ -234,14 +234,14 @@ QBasicReadWriteLock::contendedTryLockForRead(QDeadlineTimer timeout, void *dd)
             return d->recursiveLockForRead(timeout);
 
         auto lock = qt_unique_lock(d->mutex);
-        if (d != d_ptr.loadRelaxed()) {
+        if (QReadWriteLockPrivate *dd = d_ptr.loadAcquire(); d != dd) {
             // d_ptr has changed: this QReadWriteLock was unlocked before we had
             // time to lock d->mutex.
             // We are holding a lock to a mutex within a QReadWriteLockPrivate
             // that is already released (or even is already re-used). That's ok
             // because the QFreeList never frees them.
             // Just unlock d->mutex (at the end of the scope) and retry.
-            d = d_ptr.loadAcquire();
+            d = dd;
             continue;
         }
         return d->lockForRead(lock, timeout);
@@ -340,11 +340,11 @@ QBasicReadWriteLock::contendedTryLockForWrite(QDeadlineTimer timeout, void *dd)
             return d->recursiveLockForWrite(timeout);
 
         auto lock = qt_unique_lock(d->mutex);
-        if (d != d_ptr.loadRelaxed()) {
+        if (QReadWriteLockPrivate *dd = d_ptr.loadAcquire(); d != dd) {
             // The mutex was unlocked before we had time to lock the mutex.
             // We are holding to a mutex within a QReadWriteLockPrivate that is already released
             // (or even is already re-used) but that's ok because the QFreeList never frees them.
-            d = d_ptr.loadAcquire();
+            d = dd;
             continue;
         }
         return d->lockForWrite(lock, timeout);
diff --git a/src/corelib/tools/qeasingcurve.cpp b/src/corelib/tools/qeasingcurve.cpp
index de68a0042ac..ce35e8ccffe 100644
--- a/src/corelib/tools/qeasingcurve.cpp
+++ b/src/corelib/tools/qeasingcurve.cpp
@@ -332,8 +332,6 @@ struct TCBPoint
     qreal _c;
     qreal _b;
 
-    TCBPoint() {}
-    TCBPoint(QPointF point, qreal t, qreal c, qreal b) : _point(point), _t(t), _c(c), _b(b) {}
 
     bool operator==(const TCBPoint &other) const
     {
@@ -1381,7 +1379,7 @@ void QEasingCurve::addTCBSegment(const QPointF &nextPoint, qreal t, qreal c, qre
     if (!d_ptr->config)
         d_ptr->config = curveToFunctionObject(d_ptr->type);
 
-    d_ptr->config->_tcbPoints.append(TCBPoint(nextPoint, t, c, b));
+    d_ptr->config->_tcbPoints.append(TCBPoint{nextPoint, t, c, b});
 
     if (nextPoint == QPointF(1.0, 1.0)) {
         d_ptr->config->_bezierCurves = tcbToBezier(d_ptr->config->_tcbPoints);