Fix SmallArray with size 0

The original breakage comes from SmallBase<T, Dimv> a couple commits ago. When I
removed the Dimv dependence, it made the base class of every SmallArray<T> the
same no matter the T, which resulted in a padding bug. But removing the base
class entirely makes sizeof(SmallArray)=0 for size 0, which is an
inconvenience. For example, one can't create a std::vector of such objects.

Options are to 1) use a special object for size 0, or reuse std::array, which
does that; or to 2) add a member or a base class that'll take space only when
the size is 0. But now I know why.

* ra/small.hh (SmallArray): As stated.
* test/sizeof.cc: Add test.

Elsewhere use SmallArray::data() in a few places instead of .cp directly.

Author: lloda

ra/small.hh

@@ -493,24 +493,17 @@ template <class T, int N> using extvector __attribute__((ext_vector_type(N))) =
 template <class T, int N> using extvector __attribute__((vector_size(N*sizeof(T)))) = T;
 #endif
 
-template <class Z, class ... T> constexpr static bool equal_to_any = (std::is_same_v<Z, T> || ...);
+template <class T, size_t N> constexpr size_t align_req = alignof(T[N]);
+template <class Z, class ... T> constexpr static bool equals_any = (std::is_same_v<Z, T> || ...);
 template <class T, size_t N>
-consteval size_t
-align_req()
-{
-    if constexpr (equal_to_any<T, char, unsigned char, short, unsigned short, int, unsigned int,
-                  long, unsigned long, long long, unsigned long long, float, double
-                  > && 0<N && 0==(N & (N-1))) {
-        return alignof(extvector<T, N>);
-    } else {
-        return alignof(T[N]);
-    }
-}
+requires (equals_any<T, char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long,
+          long long, unsigned long long, float, double> && 0<N && 0==(N & (N-1)))
+constexpr size_t align_req<T, N> = alignof(extvector<T, N>);
 
 template <class T, class Dimv, class ... nested_args>
 struct
 #if RA_OPT_SMALLVECTOR==1
-alignas(align_req<T, std::apply([](auto ... i) { return (i.len * ... * 1); }, Dimv::value)>())
+alignas(align_req<T, std::apply([](auto ... i) { return (i.len * ... * 1); }, Dimv::value)>)
 #endif
 SmallArray<T, Dimv, std::tuple<nested_args ...>>
 {
@@ -521,14 +514,16 @@ SmallArray<T, Dimv, std::tuple<nested_args ...>>
     constexpr static dim_t step(int k) { return dimv[k].step; }
     consteval static dim_t size() { return std::apply([](auto ... i) { return (i.len * ... * 1); }, dimv); }
 
-    T cp[size()]; // std::array avoids 0, but why would I
+    T cp[size()];
+    [[no_unique_address]] struct {} prevent_zero_size; // or reuse std::array
+    constexpr auto data(this auto && self) { return self.cp; }
 
     using View = ViewSmall<T *, Dimv>;
     using ViewConst = ViewSmall<T const *, Dimv>;
-    constexpr View view() { return View(cp); }
-    constexpr ViewConst view() const { return ViewConst(cp); }
+    constexpr View view() { return View(data()); }
+    constexpr ViewConst view() const { return ViewConst(data()); }
     constexpr operator View () { return View(cp); }
-    constexpr operator ViewConst () const { return ViewConst(cp); }
+    constexpr operator ViewConst () const { return ViewConst(data()); }
 
     constexpr SmallArray() {}
     constexpr SmallArray(ra::none_t) {}
@@ -558,7 +553,6 @@ SmallArray<T, Dimv, std::tuple<nested_args ...>>
 #undef ASSIGNOPS
 
     constexpr decltype(auto) back(this auto && self) { return RA_FWD(self).view().back(); }
-    constexpr auto data(this auto && self) { return self.view().data(); }
     constexpr decltype(auto) operator()(this auto && self, auto && ... a) { return RA_FWD(self).view()(RA_FWD(a) ...); }
     constexpr decltype(auto) operator[](this auto && self, auto && ... a) { return RA_FWD(self).view()(RA_FWD(a) ...); }
     constexpr decltype(auto) at(this auto && self, auto && i) { return RA_FWD(self).view().at(RA_FWD(i)); }

test/sizeof.cc

@@ -1,5 +1,5 @@
 // -*- mode: c++; coding: utf-8 -*-
-// ra-ra/test - What to expect of sizeof... no checks.
+// ra-ra/test - What to expect of sizeof...
 
 // (c) Daniel Llorens - 2023
 // This library is free software; you can redistribute it and/or modify it under
@@ -16,7 +16,7 @@ struct noargx {}; // Small uses noarg for its own
 struct sample1
 {
     uint8_t a[16];
-    [[no_unique_address]] ra::Small<int, 0> b; // adds actually 0, but I don't rely on this atm
+    [[no_unique_address]] ra::Small<int, 0> b; // 0 or 1, don't rely on this
 };
 
 struct sample2
@@ -64,6 +64,7 @@ int main()
         cout << sizeof(ra::Small<ra::none_t, 0>) << endl;
         cout << sizeof(ra::Small<noargx, 0>) << endl;
 // the following tests were broken at some point because Small had a fixed empty base class, so nesting Smalls created multiples of these which added useless padding. Not a fan of the rule but w/e - the base class wasn't doing all that much.
+// See
         {
             using nest = ra::Small<ra::Small<int, 2>, 2>;
             cout << "nest " << sizeof(nest) << " " << alignof(nest) << endl;
@@ -102,5 +103,21 @@ int main()
         cout << sizeof(sample5) << endl;
         cout << sizeof(sample6) << endl;
     }
+    tr.section("sizeof for  Small");
+    {
+        tr.info("sizeof(ra::Small<double>)").test_eq(sizeof(double), sizeof(ra::Small<double>));
+        tr.info("sizeof(ra::Small<double, 1>)").test_eq(sizeof(double), sizeof(ra::Small<double, 1>));
+        tr.info("sizeof(ra::Small<double, 2>)").test_eq(2*sizeof(double), sizeof(ra::Small<double, 2>));
+// don't rely on these.
+        tr.skip().info("sizeof(ra::Small<double, 0>)?").test_eq(0u, sizeof(ra::Small<double, 0>));
+        tr.skip().info("sizeof(ra::Small<double, 0>)?").test_eq(sizeof(double), sizeof(ra::Small<double, 0>));
+    }
+// this needs some EBO grease in SmallArray, or using std::array as member instead of T[].
+    tr.section("Small<T, 0> are allocatable");
+    {
+        using Zero = ra::Small<int, 0>;
+        ra::Big<Zero, 1> a(0, ra::none);
+        tr.test_eq(0u, a.size());
+    }
     return tr.summary();
 }

test/small-0.cc

@@ -535,14 +535,14 @@ int main()
     {
         ra::Small<int, 3, 4> a = ra::_0 - ra::_1;
         auto vn = a.view();
-        tr.test_seq(a.cp, vn.cp);
+        tr.test_seq(a.data(), vn.cp);
         static_assert(std::is_same_v<int *, decltype(vn.cp)>);
         auto vc = std::as_const(a).view();
-        tr.test_seq(a.cp, vc.cp);
+        tr.test_seq(a.data(), vc.cp);
         static_assert(std::is_same_v<int const *, decltype(vc.cp)>);
 // needs ViewSmall::ViewConst conversion op
         decltype(vc) vk = vn;
-        tr.test_seq(a.cp, vk.cp);
+        tr.test_seq(a.data(), vk.cp);
         static_assert(std::is_same_v<int const *, decltype(vk.cp)>);
     }
 // ra::shape / ra::size are static for Small types

test/small-1.cc

@@ -47,18 +47,6 @@ int main()
         x3() = transpose(y3(), ilist_t<1, 0>{});
         tr.info("transpose copy").test_eq(x3, ra::_0 - ra::_1);
     }
-    tr.section("sizeof");
-    {
-// These all static, but show the numbers if there's an error.
-        tr.info("sizeof(ra::Small<double>)")
-            .test_eq(sizeof(double), sizeof(ra::Small<double>));
-        tr.info("sizeof(ra::Small<double, 0>)")
-            .test(sizeof(double)==sizeof(ra::Small<double, 0>) || 0==sizeof(ra::Small<double, 0>)); // don't rely on either.
-        tr.info("sizeof(ra::Small<double, 1>)")
-            .test_eq(sizeof(double), sizeof(ra::Small<double, 1>));
-        tr.info("sizeof(ra::Small<double, 2>)")
-            .test_eq(2*sizeof(double), sizeof(ra::Small<double, 2>));
-    }
     tr.section("internal fields");
     {
         {