Remove endian functions from sus::assertions

std::endian in C++20 will do fine. Note there's no equivalent interface
in Rust std to port over.

sus/CMakeLists.txt

@@ -20,7 +20,6 @@ target_link_libraries(subspace
 target_sources(subspace PUBLIC
     "assertions/check.h"
     "assertions/debug_check.h"
-    "assertions/endian.h"
     "assertions/panic.h"
     "assertions/panic.cc"
     "assertions/unreachable.h"
@@ -242,7 +241,6 @@ if(${SUBSPACE_BUILD_TESTS})
 
     add_executable(subspace_unittests
         "assertions/check_unittest.cc"
-        "assertions/endian_unittest.cc"
         "assertions/panic_unittest.cc"
         "assertions/unreachable_unittest.cc"
         "boxed/box_unittest.cc"

sus/num/__private/signed_integer_methods.inc

@@ -1881,7 +1881,7 @@ sus_pure constexpr u32 log(_self base) const& noexcept {
 ///
 /// On big endian this is a no-op. On little endian the bytes are swapped.
 sus_pure static constexpr _self from_be(_self x) noexcept {
-  if constexpr (::sus::assertions::is_big_endian())
+  if constexpr (std::endian::native == std::endian::big)
     return x;
   else
     return x.swap_bytes();
@@ -1891,7 +1891,7 @@ sus_pure static constexpr _self from_be(_self x) noexcept {
 ///
 /// On little endian this is a no-op. On big endian the bytes are swapped.
 sus_pure static constexpr _self from_le(_self x) noexcept {
-  if constexpr (::sus::assertions::is_little_endian())
+  if constexpr (std::endian::native == std::endian::little)
     return x;
   else
     return x.swap_bytes();
@@ -1901,7 +1901,7 @@ sus_pure static constexpr _self from_le(_self x) noexcept {
 ///
 /// On big endian this is a no-op. On little endian the bytes are swapped.
 sus_pure constexpr _self to_be() const& noexcept {
-  if constexpr (::sus::assertions::is_big_endian())
+  if constexpr (std::endian::native == std::endian::big)
     return *this;
   else
     return swap_bytes();
@@ -1911,7 +1911,7 @@ sus_pure constexpr _self to_be() const& noexcept {
 ///
 /// On little endian this is a no-op. On big endian the bytes are swapped.
 sus_pure constexpr _self to_le() const& noexcept {
-  if constexpr (::sus::assertions::is_little_endian())
+  if constexpr (std::endian::native == std::endian::little)
     return *this;
   else
     return swap_bytes();

sus/num/__private/signed_integer_methods_impl.inc

@@ -51,12 +51,12 @@ _self::to_ne_bytes() const& noexcept {
     auto uval = __private::into_unsigned(primitive_value);
     for (usize i; i < ::sus::mem::size_of<_primitive>(); i += 1u) {
       const auto last_byte = static_cast<uint8_t>(uval & 0xff);
-      if (sus::assertions::is_little_endian())
+      if (std::endian::native == std::endian::little)
         bytes[i] = last_byte;
       else
         bytes[::sus::mem::size_of<_primitive>() - 1u - i] = last_byte;
-      /* If _self is one byte, this shift would be UB. But it's also not needed
-         since the loop will not run again. */
+      // If _self is one byte, this shift would be UB. But it's also not needed
+      // since the loop will not run again.
       if constexpr (::sus::mem::size_of<_primitive>() > 1u) uval >>= 8u;
     }
     return bytes;

sus/num/__private/unsigned_integer_methods.inc

@@ -1655,7 +1655,7 @@ sus_pure constexpr _self wrapping_next_power_of_two() const& noexcept {
 ///
 /// On big endian this is a no-op. On little endian the bytes are swapped.
 [[nodiscard]] sus_pure static constexpr _self from_be(const _self& x) noexcept {
-  if constexpr (::sus::assertions::is_big_endian())
+  if constexpr (std::endian::native == std::endian::big)
     return x;
   else
     return x.swap_bytes();
@@ -1665,7 +1665,7 @@ sus_pure constexpr _self wrapping_next_power_of_two() const& noexcept {
 ///
 /// On little endian this is a no-op. On big endian the bytes are swapped.
 [[nodiscard]] sus_pure static constexpr _self from_le(const _self& x) noexcept {
-  if constexpr (::sus::assertions::is_little_endian())
+  if constexpr (std::endian::native == std::endian::little)
     return x;
   else
     return x.swap_bytes();
@@ -1675,7 +1675,7 @@ sus_pure constexpr _self wrapping_next_power_of_two() const& noexcept {
 ///
 /// On big endian this is a no-op. On little endian the bytes are swapped.
 sus_pure constexpr _self to_be() const& noexcept {
-  if constexpr (::sus::assertions::is_big_endian())
+  if constexpr (std::endian::native == std::endian::big)
     return *this;
   else
     return swap_bytes();
@@ -1685,7 +1685,7 @@ sus_pure constexpr _self to_be() const& noexcept {
 ///
 /// On little endian this is a no-op. On big endian the bytes are swapped.
 sus_pure constexpr _self to_le() const& noexcept {
-  if constexpr (::sus::assertions::is_little_endian())
+  if constexpr (std::endian::native == std::endian::little)
     return *this;
   else
     return swap_bytes();

sus/num/__private/unsigned_integer_methods_impl.inc

@@ -477,12 +477,12 @@ _self::to_ne_bytes() const& noexcept {
     auto uval = primitive_value;
     for (usize i; i < ::sus::mem::size_of<_primitive>(); i += 1u) {
       const auto last_byte = static_cast<uint8_t>(uval & 0xff);
-      if (sus::assertions::is_little_endian())
+      if (std::endian::native == std::endian::little)
         bytes[i] = last_byte;
       else
         bytes[::sus::mem::size_of<_primitive>() - 1u - i] = last_byte;
       // If _self is one byte, this shift would be UB. But it's also not needed
-      //   since the loop will not run again.
+      // since the loop will not run again.
       if constexpr (::sus::mem::size_of<_primitive>() > 1u) uval >>= 8u;
     }
     return bytes;

sus/num/f32_unittest.cc

@@ -1065,7 +1065,7 @@ TEST(f32, ToLeBytes) {
 
 TEST(f32, ToNeBytes) {
   auto array = (12.5_f32).to_ne_bytes();
-  auto expected = sus::assertions::is_big_endian()
+  auto expected = std::endian::native == std::endian::big
                       ? sus::Array<u8, 4>(0x41_u8, 0x48_u8, 0x00_u8, 0x00_u8)
                       : sus::Array<u8, 4>(0x00_u8, 0x00_u8, 0x48_u8, 0x41_u8);
   EXPECT_EQ(array, expected);
@@ -1084,7 +1084,7 @@ TEST(f32, FromLeBytes) {
 }
 
 TEST(f32, FromNeBytes) {
-  if constexpr (sus::assertions::is_big_endian()) {
+  if constexpr (std::endian::native == std::endian::big) {
     auto value = f32::from_ne_bytes(
         sus::Array<u8, 4>(0x41_u8, 0x48_u8, 0x00_u8, 0x00_u8));
     EXPECT_EQ(value, 12.5_f32);

sus/num/f64_unittest.cc

@@ -1059,7 +1059,7 @@ TEST(f64, FromLeBytes) {
 }
 
 TEST(f64, FromNeBytes) {
-  if constexpr (sus::assertions::is_big_endian()) {
+  if constexpr (std::endian::native == std::endian::big) {
     auto value = f64::from_ne_bytes(sus::Array<u8, 8>(0x40_u8, 0x29_u8, 0x00_u8,
                                                       0x00_u8, 0x00_u8, 0x00_u8,
                                                       0x00_u8, 0x00_u8));