QRM: specialize row_traits for std::array

std::tuple_element is implemented for std::array, so we end up using the
tuple  specialization of row_traits for a QRangeModel(std::array<T, N>).
This is semantically wrong, but it also breaks the build when using a
large array.

The tuple specialization uses a helper to test if all elements in the
tuple have the same type. With large arrays, this hits the compiler's
limit for fold-expressions, which defaults with clang to 256.

Specialize row_traits for std::array as well as C arrays; we know that
all elements are of the same type. To avoid ambiguity,
don't consider a std::array as a tuple. Introduce a
array_like detector that is true for std::array and C arrays of any type
and overload for_element_at using that detector (we have to, as we need
the array as a universal reference).

For the same reason, avoid the fold expression in meta_type_at if the
row type is an array. All types are the same anyway, so we can just
pick the first.

Pick-to: 6.10
Change-Id: Ic49e222d7b3390f9e4cc15ec531f8a97981ab0d5
Reviewed-by: Artem Dyomin <artem.dyomin@qt.io>

Author: vohi

src/corelib/itemmodels/qrangemodel_impl.h

@@ -302,11 +302,22 @@ namespace QRangeModelDetails
 
     template <typename T, typename = void>
     struct tuple_like : std::false_type {};
+    template <typename T, std::size_t N>
+    struct tuple_like<std::array<T, N>> : std::false_type {};
     template <typename T>
     struct tuple_like<T, std::void_t<std::tuple_element_t<0, wrapped_t<T>>>> : std::true_type {};
     template <typename T>
     [[maybe_unused]] static constexpr bool tuple_like_v = tuple_like<T>::value;
 
+    template <typename T, typename = void>
+    struct array_like : std::false_type {};
+    template <typename T, std::size_t N>
+    struct array_like<std::array<T, N>> : std::true_type {};
+    template <typename T, std::size_t N>
+    struct array_like<T[N]> : std::true_type {};
+    template <typename T>
+    [[maybe_unused]] static constexpr bool array_like_v = array_like<T>::value;
+
     template <typename T, typename = void>
     struct has_metaobject : std::false_type {};
     template <typename T>
@@ -556,9 +567,9 @@ namespace QRangeModelDetails
     struct row_traits<T, std::enable_if_t<tuple_like_v<T> && !has_metaobject_v<T>>>
         : tuple_row_traits<T> {};
 
-    // Specialization for C arrays
+    // Specialization for C arrays and std::array
     template <typename T, std::size_t N>
-    struct row_traits<T[N]>
+    struct row_traits<std::array<T, N>>
     {
         static_assert(q20::in_range<int>(N));
         static constexpr int static_size = int(N);
@@ -567,6 +578,9 @@ namespace QRangeModelDetails
         static constexpr bool hasMetaObject = false;
     };
 
+    template <typename T, std::size_t N>
+    struct row_traits<T[N]> : row_traits<std::array<T, N>> {};
+
     template <typename T>
     struct metaobject_row_traits
     {
@@ -794,18 +808,21 @@ class QRangeModelImplBase : public QtPrivate::QQuasiVirtualInterface<QRangeModel
     using Self = QRangeModelImplBase;
     using QtPrivate::QQuasiVirtualInterface<Self>::Method;
 protected:
-    // Helpers for calling a lambda with the tuple element at a runtime index.
-    template <typename Tuple, typename F, size_t ...Is>
-    static void call_at(Tuple &&tuple, size_t idx, std::index_sequence<Is...>, F &&function)
+    // Helpers for calling a lambda with the element of a statically
+    // sized range (tuple or array) with a runtime index.
+    template <typename Tuple, typename F, std::size_t ...Is>
+    static void call_at(Tuple &&tuple, std::size_t idx, std::index_sequence<Is...>, F &&function)
     {
+        static_assert(QRangeModelDetails::tuple_like_v<q20::remove_cvref_t<Tuple>>);
         if (QRangeModelDetails::isValid(tuple))
             ((Is == idx ? static_cast<void>(function(get<Is>(
                             QRangeModelDetails::refTo(std::forward<Tuple>(tuple)))))
                         : static_cast<void>(0)), ...);
     }
 
-    template <typename T, typename F>
-    static auto for_element_at(T &&tuple, size_t idx, F &&function)
+    template <typename T, typename F,
+              std::enable_if_t<QRangeModelDetails::tuple_like_v<q20::remove_cvref_t<T>>, bool> = true>
+    static auto for_element_at(T &&tuple, std::size_t idx, F &&function)
     {
         using type = QRangeModelDetails::wrapped_t<T>;
         constexpr size_t size = std::tuple_size_v<type>;
@@ -814,6 +831,14 @@ class QRangeModelImplBase : public QtPrivate::QQuasiVirtualInterface<QRangeModel
                        std::forward<F>(function));
     }
 
+    template <typename Array, typename F,
+              std::enable_if_t<QRangeModelDetails::array_like_v<q20::remove_cvref_t<Array>>, bool> = true>
+    static auto for_element_at(Array &&array, std::size_t idx, F &&function)
+    {
+        Q_ASSERT(idx < array.size());
+        function(q23::forward_like<Array>(array[idx]));
+    }
+
     // Get the QMetaType for a tuple-element at a runtime index.
     // Used in the headerData implementation.
     template <typename Tuple, std::size_t ...I>
@@ -825,9 +850,14 @@ class QRangeModelImplBase : public QtPrivate::QQuasiVirtualInterface<QRangeModel
     static constexpr QMetaType meta_type_at(size_t idx)
     {
         using type = QRangeModelDetails::wrapped_t<T>;
-        constexpr auto size = std::tuple_size_v<type>;
-        Q_ASSERT(idx < size);
-        return makeMetaTypes<type>(std::make_index_sequence<size>{}).at(idx);
+        if constexpr (QRangeModelDetails::array_like_v<type>) {
+            Q_UNUSED(idx);
+            return QMetaType::fromType<std::tuple_element_t<0, T>>();
+        } else {
+            constexpr auto size = std::tuple_size_v<type>;
+            Q_ASSERT(idx < size);
+            return makeMetaTypes<type>(std::make_index_sequence<size>{}).at(idx);
+        }
     }
 
 public:

tests/auto/corelib/itemmodels/qrangemodel/tst_qrangemodel.cpp

@@ -63,6 +63,7 @@ private slots:
     void moveColumns();
 
     void inconsistentColumnCount();
+    void largeArrays();
 
     void tree_data();
     void tree();
@@ -1137,6 +1138,31 @@ void tst_QRangeModel::inconsistentColumnCount()
     }
 }
 
+void tst_QRangeModel::largeArrays()
+{
+    {
+        std::array<int, 10000> largeArray = {};
+        QRangeModel model(largeArray);
+        const QModelIndex index = model.index(int(largeArray.size() - 1), 0);
+        QCOMPARE(index.data(), 0);
+    }
+
+    {
+        int largeArray[10000] = {};
+        QRangeModel model(&largeArray);
+        const QModelIndex index = model.index(int(std::size(largeArray)) - 1, 0);
+        QCOMPARE(index.data(), 0);
+    }
+
+    {
+        std::array<std::array<int, 10000>, 1> largeColumn = {};
+        QRangeModel model(largeColumn);
+        const QModelIndex index = model.index(int(largeColumn.size() - 1),
+                                              int(largeColumn[0].size() - 1));
+        QCOMPARE(index.data(), 0);
+    }
+}
+
 enum class TreeProtocol {
     ValueImplicit,
     ValueReadOnly,

tests/manual/corelib/itemmodels/qrangemodel/main.cpp

@@ -192,13 +192,20 @@ class ModelFactory : public QObject
 
     std::vector<int> numbers = {1, 2, 3, 4, 5};
     QList<QString> strings = {u"one"_s, u"two"_s, u"three"_s};
+    std::array<int, 1000000> largeArray = {};
 
 public slots:
     QRangeModel *makeNumbers()
     {
         return new QRangeModel(&numbers);
     }
 
+    QRangeModel *makeLargeArray()
+    {
+        return new QRangeModel(&largeArray);
+    }
+
+
     QRangeModel *makeStrings()
     {
         return new QRangeModel(std::ref(strings));