Fix for gcc 15

* ra/ply.hh (std::formatter<ra::is_array_formattable>): Avoid forming
  std::formattable/std::formatter of const type.
* test/mpdebug.hh (ra::mp::type_name): Use demangler.

Author: lloda

ra/base.hh

@@ -10,6 +10,7 @@
 #pragma once
 #include "tuples.hh"
 #include <array>
+#include <format>
 #include <ranges>
 #include <vector>
 #include <iosfwd> // for format, ss.
@@ -269,8 +270,8 @@ operator<<(std::ostream & o, std::source_location const & loc)
     return o << loc.file_name() << ":" << loc.line() << "," << loc.column();
 }
 
-template <class A> requires (std::formattable<A, char>) constexpr void print1(auto & o, A && a) { std::print(o, "{}", RA_FWD(a)); }
-template <class A> requires (!std::formattable<A, char>) constexpr void print1(auto & o, A && a) { o << RA_FWD(a); }
+constexpr void print1(auto & o, std::formattable<char> auto && a) { std::print(o, "{}", RA_FWD(a)); }
+constexpr void print1(auto & o, auto && a) { o << RA_FWD(a); }
 constexpr auto & print(auto & o, auto && ... a) { (print1(o, RA_FWD(a)), ...); return o; }
 constexpr std::string format(auto && ... a) { std::ostringstream o; print(o, RA_FWD(a) ...); return o.str(); }
 constexpr std::string const & format(std::string const & s) { return s; }

ra/expr.hh

@@ -356,23 +356,23 @@ template <bool checkp, IteratorConcept ... P, int ... I>
 struct Match<checkp, std::tuple<P ...>, mp::int_list<I ...>>
 {
     std::tuple<P ...> t;
-    constexpr static rank_t rs = [] { rank_t r=BAD; return ((r=choose_rank(ra::rank_s<P>(), r)), ...); }();
+    constexpr static rank_t rs = [] { rank_t r=BAD; return ((r=choose_rank(rank_s<P>(), r)), ...); }();
 
 // 0: fail, 1: rt, 2: pass
     consteval static int
     check_s()
     {
-        if constexpr (sizeof...(P)<2 || sizeof...(P)==1+(bool(0==ra::rank_s<P>()) + ...)) {
+        if constexpr (sizeof...(P)<2 || sizeof...(P)==1+(bool(0==rank_s<P>()) + ...)) {
             return 2;
         } else if constexpr (ANY!=rs) {
             bool tbc = false;
             for (int k=0; k<rs; ++k) {
                 dim_t ls = len_s(k);
-                if (((k<ra::rank_s<P>() && ls!=choose_len(std::decay_t<P>::len_s(k), ls)) || ...)) {
+                if (((k<rank_s<P>() && ls!=choose_len(std::decay_t<P>::len_s(k), ls)) || ...)) {
                     return 0;
                 }
-                int anyk = ((k<ra::rank_s<P>() && (ANY==std::decay_t<P>::len_s(k))) + ...);
-                int fixk = ((k<ra::rank_s<P>() && (0<=std::decay_t<P>::len_s(k))) + ...);
+                int anyk = ((k<rank_s<P>() && (ANY==std::decay_t<P>::len_s(k))) + ...);
+                int fixk = ((k<rank_s<P>() && (0<=std::decay_t<P>::len_s(k))) + ...);
                 tbc = tbc || (anyk>0 && anyk+fixk>1);
             }
             return tbc ? 1 : 2;
@@ -423,7 +423,7 @@ struct Match<checkp, std::tuple<P ...>, mp::int_list<I ...>>
     len_s(int k)
     {
         auto f = [&k]<class A>(dim_t s) {
-            constexpr rank_t ar = ra::rank_s<A>();
+            constexpr rank_t ar = rank_s<A>();
             return (ar<0 || k<ar) ? choose_len(A::len_s(k), s) : s;
         };
         dim_t s = BAD; (void)(((s = f.template operator()<std::decay_t<P>>(s)) < 0) && ...);

ra/ply.hh

@@ -13,7 +13,6 @@
 
 #pragma once
 #include "expr.hh"
-#include <format>
 
 namespace ra {
 
@@ -353,8 +352,8 @@ template <ra::is_array_formattable A>
 struct std::formatter<A>
 {
     ra::format_t fmt;
-    std::conditional_t<std::formattable<ra::value_t<A>, char>,
-                       std::formatter<ra::value_t<A>>, ra::ostream_formatter> under;
+    std::conditional_t<std::formattable<ra::ncvalue_t<A>, char>,
+                       std::formatter<ra::ncvalue_t<A>>, ra::ostream_formatter> under;
 
     constexpr auto
     parse(auto & ctx)

test/mpdebug.hh

@@ -10,7 +10,7 @@
 #pragma once
 #include "ra/tuples.hh"
 #include <typeinfo>
-#include <sys/types.h>
+#include <cxxabi.h>
 
 namespace ra::mp {
 
@@ -41,17 +41,8 @@ template <class T>
 std::string
 type_name()
 {
-    using TR = std::remove_cvref_t<T>;
-    std::string r = typeid(TR).name();
-    if (std::is_const_v<TR>)
-        r += " const";
-    if (std::is_volatile_v<TR>)
-        r += " volatile";
-    if (std::is_lvalue_reference_v<T>)
-        r += " &";
-    else if (std::is_rvalue_reference_v<T>)
-        r += " &&";
-    return r;
+    int status;
+    return abi::__cxa_demangle(typeid(T).name(), NULL, NULL, &status);
 }
 
 template <class A, int ... I> struct check_idx { constexpr static bool value = false; };