From 3923312fbbc7c732844892ff2e1324aed463aa11 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Tue, 25 Feb 2025 15:04:28 -0700
Subject: [PATCH] :arrow_up: Add support for clang-19

---
 .github/workflows/unit_tests.yml        | 19 +++++--
 README.md                               |  2 +-
 include/stdx/atomic_bitset.hpp          | 25 ++++----
 include/stdx/bit.hpp                    | 76 ++++++++++++-------------
 include/stdx/bitset.hpp                 | 10 ++--
 include/stdx/byterator.hpp              | 34 +++++------
 include/stdx/ct_format.hpp              |  4 +-
 include/stdx/ct_string.hpp              |  6 +-
 include/stdx/cx_map.hpp                 | 12 ++--
 include/stdx/cx_multimap.hpp            | 12 ++--
 include/stdx/cx_queue.hpp               |  8 +--
 include/stdx/cx_set.hpp                 |  4 +-
 include/stdx/cx_vector.hpp              | 38 +++++++------
 include/stdx/intrusive_forward_list.hpp | 12 ++--
 include/stdx/intrusive_list.hpp         | 12 ++--
 include/stdx/numeric.hpp                |  4 +-
 include/stdx/optional.hpp               | 28 +++++----
 include/stdx/rollover.hpp               | 29 ++++++----
 include/stdx/span.hpp                   | 20 +++----
 include/stdx/tuple.hpp                  | 35 ++++++------
 include/stdx/tuple_algorithms.hpp       | 12 ++--
 include/stdx/type_traits.hpp            |  4 +-
 include/stdx/udls.hpp                   | 24 ++++----
 test/detail/tuple_types.hpp             |  4 +-
 test/optional.cpp                       |  8 +--
 25 files changed, 235 insertions(+), 207 deletions(-)

diff --git a/.github/workflows/unit_tests.yml b/.github/workflows/unit_tests.yml
index e375007..6c08d9d 100644
--- a/.github/workflows/unit_tests.yml
+++ b/.github/workflows/unit_tests.yml
@@ -13,7 +13,7 @@ env:
   DEBIAN_FRONTEND: noninteractive
   CMAKE_GENERATOR: Ninja
   DEFAULT_CXX_STANDARD: 20
-  DEFAULT_LLVM_VERSION: 18
+  DEFAULT_LLVM_VERSION: 19
   DEFAULT_GCC_VERSION: 13
   MULL_LLVM_VERSION: 17
   HYPOTHESIS_PROFILE: default
@@ -29,7 +29,7 @@ jobs:
       fail-fast: false
       matrix:
         compiler: [clang, gcc]
-        version: [12, 13, 16, 17, 18]
+        version: [12, 13, 16, 17, 18, 19]
         cxx_standard: [17, 20]
         stdlib: [libstdc++, libc++]
         build_type: [Debug]
@@ -38,6 +38,15 @@ jobs:
             cc: "clang"
             cxx: "clang++"
             cxx_flags: "-stdlib=libstdc++"
+          - version: 19
+            compiler: clang
+            install: sudo apt update && sudo apt install -y clang-19
+            toolchain_root: "/usr/lib/llvm-19"
+          - version: 19
+            compiler: clang
+            stdlib: libc++
+            install: sudo apt update && sudo apt install -y clang-19 libc++-19-dev libc++abi-19-dev
+            cxx_flags: "-stdlib=libc++"
           - version: 18
             compiler: clang
             install: sudo apt update && sudo apt install -y clang-18
@@ -80,6 +89,8 @@ jobs:
             cxx: "g++-12"
             cxx_flags: ""
         exclude:
+          - compiler: gcc
+            version: 19
           - compiler: gcc
             version: 18
           - compiler: gcc
@@ -293,8 +304,8 @@ jobs:
           - compiler: clang
             cc: "clang"
             cxx: "clang++"
-            install: sudo apt update && sudo apt install -y clang-18
-            toolchain_root: "/usr/lib/llvm-18"
+            install: sudo apt update && sudo apt install -y clang-19
+            toolchain_root: "/usr/lib/llvm-19"
           - compiler: gcc
             cc: "gcc-13"
             cxx: "g++-13"
diff --git a/README.md b/README.md
index 72e9087..9a85bcb 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ Some of the extras are available only with C++20 or later.
  
 *stdx* supports:
  
-- clang 14 through 18
+- clang 14 through 19
 - gcc 12 through 13
 
 See the [full documentation](https://intel.github.io/cpp-std-extensions/).
diff --git a/include/stdx/atomic_bitset.hpp b/include/stdx/atomic_bitset.hpp
index 3cf9941..4cf5ccc 100644
--- a/include/stdx/atomic_bitset.hpp
+++ b/include/stdx/atomic_bitset.hpp
@@ -153,8 +153,8 @@ class atomic_bitset {
         return set(lsb, static_cast<msb_t>(l + length - 1), value, order);
     }
 
-    auto set(std::memory_order order = std::memory_order_seq_cst)
-        LIFETIMEBOUND -> atomic_bitset & {
+    auto set(std::memory_order order = std::memory_order_seq_cst) LIFETIMEBOUND
+        -> atomic_bitset & {
         atomic::store(storage, mask, order);
         return *this;
     }
@@ -167,32 +167,33 @@ class atomic_bitset {
             storage, static_cast<elem_t>(~(bit << pos)), order)};
     }
 
-    auto
-    reset(lsb_t lsb, msb_t msb,
-          std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
+    auto reset(lsb_t lsb, msb_t msb,
+               std::memory_order order = std::memory_order_seq_cst)
+        -> bitset_t {
         auto const l = to_underlying(lsb);
         auto const m = to_underlying(msb);
         auto const shifted_value = bit_mask<elem_t>(m, l);
         return bitset_t{atomic::fetch_and(storage, ~shifted_value, order)};
     }
 
-    auto
-    reset(lsb_t lsb, length_t len,
-          std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
+    auto reset(lsb_t lsb, length_t len,
+               std::memory_order order = std::memory_order_seq_cst)
+        -> bitset_t {
         auto const l = to_underlying(lsb);
         auto const length = to_underlying(len);
         return reset(lsb, static_cast<msb_t>(l + length - 1), order);
     }
 
-    auto reset(std::memory_order order = std::memory_order_seq_cst)
-        LIFETIMEBOUND -> atomic_bitset & {
+    auto
+    reset(std::memory_order order = std::memory_order_seq_cst) LIFETIMEBOUND
+        -> atomic_bitset & {
         atomic::store(storage, elem_t{}, order);
         return *this;
     }
 
     template <typename T>
-    auto flip(T idx,
-              std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
+    auto flip(T idx, std::memory_order order = std::memory_order_seq_cst)
+        -> bitset_t {
         auto const pos = static_cast<std::size_t>(to_underlying(idx));
         return bitset_t{
             atomic::fetch_xor(storage, static_cast<elem_t>(bit << pos), order)};
diff --git a/include/stdx/bit.hpp b/include/stdx/bit.hpp
index 2eadb95..9e8af51 100644
--- a/include/stdx/bit.hpp
+++ b/include/stdx/bit.hpp
@@ -47,8 +47,8 @@ using std::bit_cast;
 
 #if __cpp_lib_byteswap < 202110L
 template <typename T>
-[[nodiscard]] constexpr auto
-byteswap(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto byteswap(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if constexpr (sizeof(T) == sizeof(std::uint16_t)) {
         return __builtin_bswap16(x);
     } else if constexpr (sizeof(T) == sizeof(std::uint32_t)) {
@@ -67,8 +67,8 @@ using std::byteswap;
 
 #if __cpp_lib_bitops < 201907L
 template <typename T>
-[[nodiscard]] constexpr auto
-countl_zero(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
+[[nodiscard]] constexpr auto countl_zero(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, int> {
     if (x == 0) {
         return std::numeric_limits<T>::digits;
     }
@@ -88,8 +88,8 @@ countl_zero(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-countr_zero(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
+[[nodiscard]] constexpr auto countr_zero(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, int> {
     if (x == 0) {
         return std::numeric_limits<T>::digits;
     }
@@ -104,20 +104,20 @@ countr_zero(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-countl_one(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
+[[nodiscard]] constexpr auto countl_one(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, int> {
     return countl_zero(T(~x));
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-countr_one(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
+[[nodiscard]] constexpr auto countr_one(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, int> {
     return countr_zero(T(~x));
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-popcount(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
+[[nodiscard]] constexpr auto popcount(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, int> {
     if constexpr (sizeof(T) <= sizeof(unsigned int)) {
         return __builtin_popcount(x);
     } else if constexpr (sizeof(T) <=
@@ -130,8 +130,8 @@ popcount(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
 
 namespace detail {
 template <typename T>
-[[nodiscard]] constexpr auto
-rotl(T x, T s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto rotl(T x, T s) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 #ifdef __clang__
     if constexpr (sizeof(T) == sizeof(std::uint8_t)) {
         return __builtin_rotateleft8(x, s);
@@ -148,8 +148,8 @@ rotl(T x, T s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 #endif
 }
 template <typename T>
-[[nodiscard]] constexpr auto
-rotr(T x, T s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto rotr(T x, T s) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 #ifdef __clang__
     if constexpr (sizeof(T) == sizeof(std::uint8_t)) {
         return __builtin_rotateright8(x, s);
@@ -168,8 +168,8 @@ rotr(T x, T s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 } // namespace detail
 
 template <typename T>
-[[nodiscard]] constexpr auto
-rotl(T x, int s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto rotl(T x, int s) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if (s == 0) {
         return x;
     }
@@ -180,8 +180,8 @@ rotl(T x, int s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-rotr(T x, int s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto rotr(T x, int s) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if (s == 0) {
         return x;
     }
@@ -204,20 +204,20 @@ using std::rotr;
 
 #if __cpp_lib_int_pow2 < 202002L
 template <typename T>
-[[nodiscard]] constexpr auto
-has_single_bit(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, bool> {
+[[nodiscard]] constexpr auto has_single_bit(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, bool> {
     return x and not(x & (x - 1));
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-bit_width(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
+[[nodiscard]] constexpr auto bit_width(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, int> {
     return std::numeric_limits<T>::digits - countl_zero(x);
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-bit_ceil(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto bit_ceil(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if (x <= 1U) {
         return 1U;
     }
@@ -225,8 +225,8 @@ bit_ceil(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-bit_floor(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto bit_floor(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if (x == 0) {
         return x;
     }
@@ -240,8 +240,8 @@ using std::has_single_bit;
 #endif
 
 template <typename T>
-[[nodiscard]] constexpr auto
-to_le(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto to_le(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if constexpr (stdx::endian::native == stdx::endian::big) {
         return byteswap(x);
     } else {
@@ -250,8 +250,8 @@ to_le(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-to_be(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto to_be(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if constexpr (stdx::endian::native == stdx::endian::little) {
         return byteswap(x);
     } else {
@@ -260,8 +260,8 @@ to_be(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-from_le(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto from_le(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if constexpr (stdx::endian::native == stdx::endian::big) {
         return byteswap(x);
     } else {
@@ -270,8 +270,8 @@ from_le(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
 }
 
 template <typename T>
-[[nodiscard]] constexpr auto
-from_be(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
+[[nodiscard]] constexpr auto from_be(T x) noexcept
+    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
     if constexpr (stdx::endian::native == stdx::endian::little) {
         return byteswap(x);
     } else {
@@ -341,8 +341,8 @@ template <typename To, typename From> constexpr auto bit_unpack(From arg) {
 
 namespace detail {
 template <typename T, std::size_t Bit>
-constexpr auto
-mask_bits() -> std::enable_if_t<Bit <= std::numeric_limits<T>::digits, T> {
+constexpr auto mask_bits()
+    -> std::enable_if_t<Bit <= std::numeric_limits<T>::digits, T> {
     if constexpr (Bit == std::numeric_limits<T>::digits) {
         return std::numeric_limits<T>::max();
     } else {
diff --git a/include/stdx/bitset.hpp b/include/stdx/bitset.hpp
index 9600dc2..8115f98 100644
--- a/include/stdx/bitset.hpp
+++ b/include/stdx/bitset.hpp
@@ -243,8 +243,8 @@ class bitset {
         return *this;
     }
 
-    constexpr auto set(lsb_t lsb, msb_t msb,
-                       bool value = true) LIFETIMEBOUND -> bitset & {
+    constexpr auto set(lsb_t lsb, msb_t msb, bool value = true) LIFETIMEBOUND
+        -> bitset & {
         auto const l = to_underlying(lsb);
         auto const m = to_underlying(msb);
         auto [l_index, l_offset] = indices(l);
@@ -272,8 +272,8 @@ class bitset {
         return *this;
     }
 
-    constexpr auto set(lsb_t lsb, length_t len,
-                       bool value = true) LIFETIMEBOUND -> bitset & {
+    constexpr auto set(lsb_t lsb, length_t len, bool value = true) LIFETIMEBOUND
+        -> bitset & {
         auto const l = to_underlying(lsb);
         auto const length = to_underlying(len);
         return set(lsb, static_cast<msb_t>(l + length - 1), value);
@@ -398,7 +398,7 @@ class bitset {
 
     constexpr auto operator<<=(std::size_t pos) LIFETIMEBOUND->bitset & {
         auto dst = storage_size - 1;
-        auto const start = dst - pos / storage_elem_size;
+        auto const start = dst - (pos / storage_elem_size);
         pos %= storage_elem_size;
 
         if (pos == 0) {
diff --git a/include/stdx/byterator.hpp b/include/stdx/byterator.hpp
index 06f7782..01c9901 100644
--- a/include/stdx/byterator.hpp
+++ b/include/stdx/byterator.hpp
@@ -42,8 +42,8 @@ template <typename T> class byterator {
     template <typename It,
               std::enable_if_t<std::is_same_v<detail::iterator_value_t<It>, T>,
                                int> = 0>
-    [[nodiscard]] constexpr friend auto operator==(byterator const &x,
-                                                   It y) -> bool {
+    [[nodiscard]] constexpr friend auto operator==(byterator const &x, It y)
+        -> bool {
         return static_cast<void const *>(x.ptr) ==
                static_cast<void const *>(stdx::to_address(y));
     }
@@ -60,18 +60,18 @@ template <typename T> class byterator {
     }
 
     template <typename It>
-    [[nodiscard]] constexpr friend auto operator==(It y,
-                                                   byterator const &x) -> bool {
+    [[nodiscard]] constexpr friend auto operator==(It y, byterator const &x)
+        -> bool {
         return x == y;
     }
     template <typename It>
-    [[nodiscard]] constexpr friend auto operator!=(byterator const &x,
-                                                   It y) -> bool {
+    [[nodiscard]] constexpr friend auto operator!=(byterator const &x, It y)
+        -> bool {
         return not(x == y);
     }
     template <typename It>
-    [[nodiscard]] constexpr friend auto operator!=(It y,
-                                                   byterator const &x) -> bool {
+    [[nodiscard]] constexpr friend auto operator!=(It y, byterator const &x)
+        -> bool {
         return not(x == y);
     }
 
@@ -135,8 +135,9 @@ template <typename T> class byterator {
         return *this;
     }
 
-    [[nodiscard]] friend constexpr auto
-    operator+(byterator i, difference_type d) -> byterator {
+    [[nodiscard]] friend constexpr auto operator+(byterator i,
+                                                  difference_type d)
+        -> byterator {
         i += d;
         return i;
     }
@@ -145,21 +146,22 @@ template <typename T> class byterator {
         i += d;
         return i;
     }
-    [[nodiscard]] friend constexpr auto
-    operator-(byterator i, difference_type d) -> byterator {
+    [[nodiscard]] friend constexpr auto operator-(byterator i,
+                                                  difference_type d)
+        -> byterator {
         i -= d;
         return i;
     }
-    [[nodiscard]] friend constexpr auto
-    operator-(byterator x, byterator y) -> difference_type {
+    [[nodiscard]] friend constexpr auto operator-(byterator x, byterator y)
+        -> difference_type {
         return x.ptr - y.ptr;
     }
 
     [[nodiscard]] constexpr auto operator[](difference_type n) -> byte_t & {
         return ptr[n];
     }
-    [[nodiscard]] constexpr auto
-    operator[](difference_type n) const -> byte_t const & {
+    [[nodiscard]] constexpr auto operator[](difference_type n) const
+        -> byte_t const & {
         return ptr[n];
     }
 
diff --git a/include/stdx/ct_format.hpp b/include/stdx/ct_format.hpp
index 9524f0a..a717e02 100644
--- a/include/stdx/ct_format.hpp
+++ b/include/stdx/ct_format.hpp
@@ -26,8 +26,8 @@ template <std::size_t N> constexpr auto format_as(stdx::ct_string<N> const &s) {
 }
 
 template <typename Str, typename Args> struct format_result {
-    CONSTEVAL static auto
-    ct_string_convertible() -> std::bool_constant<Args::size() == 0>;
+    CONSTEVAL static auto ct_string_convertible()
+        -> std::bool_constant<Args::size() == 0>;
 
     [[no_unique_address]] Str str;
     [[no_unique_address]] Args args{};
diff --git a/include/stdx/ct_string.hpp b/include/stdx/ct_string.hpp
index 79dc1f9..1b72874 100644
--- a/include/stdx/ct_string.hpp
+++ b/include/stdx/ct_string.hpp
@@ -121,9 +121,9 @@ template <ct_string S, char C> [[nodiscard]] consteval auto split() {
 }
 
 template <std::size_t N, std::size_t M>
-[[nodiscard]] constexpr auto
-operator+(ct_string<N> const &lhs,
-          ct_string<M> const &rhs) -> ct_string<N + M - 1> {
+[[nodiscard]] constexpr auto operator+(ct_string<N> const &lhs,
+                                       ct_string<M> const &rhs)
+    -> ct_string<N + M - 1> {
     ct_string<N + M - 1> ret{};
     for (auto i = std::size_t{}; i < lhs.size(); ++i) {
         // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-*)
diff --git a/include/stdx/cx_map.hpp b/include/stdx/cx_map.hpp
index 09c43d7..6865cad 100644
--- a/include/stdx/cx_map.hpp
+++ b/include/stdx/cx_map.hpp
@@ -50,8 +50,8 @@ template <typename Key, typename Value, std::size_t N> class cx_map {
     [[nodiscard]] constexpr auto begin() const LIFETIMEBOUND -> const_iterator {
         return std::data(storage);
     }
-    [[nodiscard]] constexpr auto
-    cbegin() const LIFETIMEBOUND -> const_iterator {
+    [[nodiscard]] constexpr auto cbegin() const LIFETIMEBOUND
+        -> const_iterator {
         return std::data(storage);
     }
 
@@ -83,8 +83,8 @@ template <typename Key, typename Value, std::size_t N> class cx_map {
         return storage[--current_size];
     }
 
-    [[nodiscard]] constexpr auto
-    get(key_type const &key) LIFETIMEBOUND -> mapped_type & {
+    [[nodiscard]] constexpr auto get(key_type const &key) LIFETIMEBOUND
+        -> mapped_type & {
         for (auto &[k, v] : *this) {
             if (k == key) {
                 return v;
@@ -92,8 +92,8 @@ template <typename Key, typename Value, std::size_t N> class cx_map {
         }
         unreachable();
     }
-    [[nodiscard]] constexpr auto
-    get(key_type const &key) const LIFETIMEBOUND -> mapped_type const & {
+    [[nodiscard]] constexpr auto get(key_type const &key) const LIFETIMEBOUND
+        -> mapped_type const & {
         for (auto const &[k, v] : *this) {
             if (k == key) {
                 return v;
diff --git a/include/stdx/cx_multimap.hpp b/include/stdx/cx_multimap.hpp
index a5ca673..86ba742 100644
--- a/include/stdx/cx_multimap.hpp
+++ b/include/stdx/cx_multimap.hpp
@@ -31,8 +31,8 @@ class cx_multimap {
     [[nodiscard]] constexpr auto begin() const LIFETIMEBOUND -> const_iterator {
         return std::begin(storage);
     }
-    [[nodiscard]] constexpr auto
-    cbegin() const LIFETIMEBOUND -> const_iterator {
+    [[nodiscard]] constexpr auto cbegin() const LIFETIMEBOUND
+        -> const_iterator {
         return std::cbegin(storage);
     }
 
@@ -82,12 +82,12 @@ class cx_multimap {
         return 0;
     }
 
-    [[nodiscard]] constexpr auto
-    get(key_type const &key) LIFETIMEBOUND -> set_t & {
+    [[nodiscard]] constexpr auto get(key_type const &key) LIFETIMEBOUND
+        -> set_t & {
         return storage.get(key);
     }
-    [[nodiscard]] constexpr auto
-    get(key_type const &key) const LIFETIMEBOUND -> set_t const & {
+    [[nodiscard]] constexpr auto get(key_type const &key) const LIFETIMEBOUND
+        -> set_t const & {
         return storage.get(key);
     }
 
diff --git a/include/stdx/cx_queue.hpp b/include/stdx/cx_queue.hpp
index e9f777b..3401836 100644
--- a/include/stdx/cx_queue.hpp
+++ b/include/stdx/cx_queue.hpp
@@ -66,8 +66,8 @@ class cx_queue {
         OverflowPolicy::check_pop(current_size);
         return storage[pop_index];
     }
-    [[nodiscard]] constexpr auto front() const
-        & LIFETIMEBOUND -> const_reference {
+    [[nodiscard]] constexpr auto front() const & LIFETIMEBOUND
+                                                 -> const_reference {
         OverflowPolicy::check_pop(current_size);
         return storage[pop_index];
     }
@@ -75,8 +75,8 @@ class cx_queue {
         OverflowPolicy::check_pop(current_size);
         return storage[push_index];
     }
-    [[nodiscard]] constexpr auto back() const
-        & LIFETIMEBOUND -> const_reference {
+    [[nodiscard]] constexpr auto back() const & LIFETIMEBOUND
+                                                -> const_reference {
         OverflowPolicy::check_pop(current_size);
         return storage[push_index];
     }
diff --git a/include/stdx/cx_set.hpp b/include/stdx/cx_set.hpp
index 6e3ceee..8b0effc 100644
--- a/include/stdx/cx_set.hpp
+++ b/include/stdx/cx_set.hpp
@@ -38,8 +38,8 @@ template <typename Key, std::size_t N> class cx_set {
     [[nodiscard]] constexpr auto begin() const LIFETIMEBOUND -> const_iterator {
         return std::data(storage);
     }
-    [[nodiscard]] constexpr auto
-    cbegin() const LIFETIMEBOUND -> const_iterator {
+    [[nodiscard]] constexpr auto cbegin() const LIFETIMEBOUND
+        -> const_iterator {
         return std::data(storage);
     }
 
diff --git a/include/stdx/cx_vector.hpp b/include/stdx/cx_vector.hpp
index befb8d9..550c947 100644
--- a/include/stdx/cx_vector.hpp
+++ b/include/stdx/cx_vector.hpp
@@ -45,8 +45,8 @@ template <typename T, std::size_t N> class cx_vector {
     [[nodiscard]] constexpr auto begin() const LIFETIMEBOUND -> const_iterator {
         return std::data(storage);
     }
-    [[nodiscard]] constexpr auto
-    cbegin() const LIFETIMEBOUND -> const_iterator {
+    [[nodiscard]] constexpr auto cbegin() const LIFETIMEBOUND
+        -> const_iterator {
         return std::data(storage);
     }
 
@@ -63,32 +63,32 @@ template <typename T, std::size_t N> class cx_vector {
     [[nodiscard]] constexpr auto rbegin() LIFETIMEBOUND -> reverse_iterator {
         return end();
     }
-    [[nodiscard]] constexpr auto
-    rbegin() const LIFETIMEBOUND -> const_reverse_iterator {
+    [[nodiscard]] constexpr auto rbegin() const LIFETIMEBOUND
+        -> const_reverse_iterator {
         return end();
     }
-    [[nodiscard]] constexpr auto
-    crbegin() const LIFETIMEBOUND -> const_reverse_iterator {
+    [[nodiscard]] constexpr auto crbegin() const LIFETIMEBOUND
+        -> const_reverse_iterator {
         return cend();
     }
 
     [[nodiscard]] constexpr auto rend() LIFETIMEBOUND -> reverse_iterator {
         return begin();
     }
-    [[nodiscard]] constexpr auto
-    rend() const LIFETIMEBOUND -> const_reverse_iterator {
+    [[nodiscard]] constexpr auto rend() const LIFETIMEBOUND
+        -> const_reverse_iterator {
         return begin();
     }
-    [[nodiscard]] constexpr auto
-    crend() const LIFETIMEBOUND -> const_reverse_iterator {
+    [[nodiscard]] constexpr auto crend() const LIFETIMEBOUND
+        -> const_reverse_iterator {
         return cbegin();
     }
 
     [[nodiscard]] constexpr auto front() LIFETIMEBOUND -> reference {
         return storage[0];
     }
-    [[nodiscard]] constexpr auto
-    front() const LIFETIMEBOUND -> const_reference {
+    [[nodiscard]] constexpr auto front() const LIFETIMEBOUND
+        -> const_reference {
         return storage[0];
     }
     [[nodiscard]] constexpr auto back() LIFETIMEBOUND -> reference {
@@ -130,8 +130,8 @@ template <typename T, std::size_t N> class cx_vector {
 
     constexpr auto clear() -> void { current_size = 0; }
 
-    constexpr auto
-    push_back(value_type const &value) LIFETIMEBOUND -> reference {
+    constexpr auto push_back(value_type const &value) LIFETIMEBOUND
+        -> reference {
         return storage[current_size++] = value;
     }
     constexpr auto push_back(value_type &&value) LIFETIMEBOUND -> reference {
@@ -149,8 +149,9 @@ template <typename T, std::size_t N> class cx_vector {
             std::forward<F>(f)(std::data(v.storage), std::size(v.storage));
     }
 
-    [[nodiscard]] friend constexpr auto
-    operator==(cx_vector const &lhs, cx_vector const &rhs) -> bool {
+    [[nodiscard]] friend constexpr auto operator==(cx_vector const &lhs,
+                                                   cx_vector const &rhs)
+        -> bool {
         if (lhs.size() != rhs.size()) {
             return false;
         }
@@ -163,8 +164,9 @@ template <typename T, std::size_t N> class cx_vector {
     }
 
 #if __cpp_impl_three_way_comparison < 201907L
-    [[nodiscard]] friend constexpr auto
-    operator!=(cx_vector const &lhs, cx_vector const &rhs) -> bool {
+    [[nodiscard]] friend constexpr auto operator!=(cx_vector const &lhs,
+                                                   cx_vector const &rhs)
+        -> bool {
         return not(lhs == rhs);
     }
 #endif
diff --git a/include/stdx/intrusive_forward_list.hpp b/include/stdx/intrusive_forward_list.hpp
index dcd01f4..c231fc9 100644
--- a/include/stdx/intrusive_forward_list.hpp
+++ b/include/stdx/intrusive_forward_list.hpp
@@ -45,17 +45,17 @@ class intrusive_forward_list {
         pointer node{};
 
 #if __cpp_impl_three_way_comparison < 201907L
-        friend constexpr auto operator==(iterator_t lhs,
-                                         iterator_t rhs) -> bool {
+        friend constexpr auto operator==(iterator_t lhs, iterator_t rhs)
+            -> bool {
             return lhs.node == rhs.node;
         }
-        friend constexpr auto operator!=(iterator_t lhs,
-                                         iterator_t rhs) -> bool {
+        friend constexpr auto operator!=(iterator_t lhs, iterator_t rhs)
+            -> bool {
             return not(lhs == rhs);
         }
 #else
-        friend constexpr auto operator==(iterator_t,
-                                         iterator_t) -> bool = default;
+        friend constexpr auto operator==(iterator_t, iterator_t)
+            -> bool = default;
 #endif
     };
 
diff --git a/include/stdx/intrusive_list.hpp b/include/stdx/intrusive_list.hpp
index 4351be3..3cee6c1 100644
--- a/include/stdx/intrusive_list.hpp
+++ b/include/stdx/intrusive_list.hpp
@@ -46,17 +46,17 @@ class intrusive_list {
         pointer node{};
 
 #if __cpp_impl_three_way_comparison < 201907L
-        friend constexpr auto operator==(iterator_t lhs,
-                                         iterator_t rhs) -> bool {
+        friend constexpr auto operator==(iterator_t lhs, iterator_t rhs)
+            -> bool {
             return lhs.node == rhs.node;
         }
-        friend constexpr auto operator!=(iterator_t lhs,
-                                         iterator_t rhs) -> bool {
+        friend constexpr auto operator!=(iterator_t lhs, iterator_t rhs)
+            -> bool {
             return not(lhs == rhs);
         }
 #else
-        friend constexpr auto operator==(iterator_t,
-                                         iterator_t) -> bool = default;
+        friend constexpr auto operator==(iterator_t, iterator_t)
+            -> bool = default;
 #endif
     };
 
diff --git a/include/stdx/numeric.hpp b/include/stdx/numeric.hpp
index a8dcc05..1fe3db2 100644
--- a/include/stdx/numeric.hpp
+++ b/include/stdx/numeric.hpp
@@ -17,8 +17,8 @@ inline namespace v1 {
 template <typename T, typename InputIt, typename ROp, typename TOp,
           typename... InputItN>
 CONSTEXPR_INVOKE auto transform_reduce(InputIt first, InputIt last, T init,
-                                       ROp rop, TOp top,
-                                       InputItN... first_n) -> T {
+                                       ROp rop, TOp top, InputItN... first_n)
+    -> T {
     while (first != last) {
         init = std::invoke(rop, std::move(init),
                            std::invoke(top, *first, *first_n...));
diff --git a/include/stdx/optional.hpp b/include/stdx/optional.hpp
index 39b33f7..29912ca 100644
--- a/include/stdx/optional.hpp
+++ b/include/stdx/optional.hpp
@@ -91,15 +91,15 @@ template <typename T, typename TS = tombstone_traits<T>> class optional {
     [[nodiscard]] constexpr auto value() & LIFETIMEBOUND -> value_type & {
         return val;
     }
-    [[nodiscard]] constexpr auto value() const
-        & LIFETIMEBOUND -> value_type const & {
+    [[nodiscard]] constexpr auto value() const & LIFETIMEBOUND
+                                                 -> value_type const & {
         return val;
     }
     [[nodiscard]] constexpr auto value() && LIFETIMEBOUND -> value_type && {
         return std::move(val);
     }
-    [[nodiscard]] constexpr auto value() const
-        && LIFETIMEBOUND -> value_type const && {
+    [[nodiscard]] constexpr auto value() const && LIFETIMEBOUND
+                                                  -> value_type const && {
         return std::move(val);
     }
 
@@ -206,14 +206,16 @@ template <typename T, typename TS = tombstone_traits<T>> class optional {
     }
 
   private:
-    [[nodiscard]] friend constexpr auto
-    operator==(optional const &lhs, optional const &rhs) -> bool {
+    [[nodiscard]] friend constexpr auto operator==(optional const &lhs,
+                                                   optional const &rhs)
+        -> bool {
         return lhs.val == rhs.val;
     }
 
 #if __cpp_impl_three_way_comparison < 201907L
-    [[nodiscard]] friend constexpr auto
-    operator!=(optional const &lhs, optional const &rhs) -> bool {
+    [[nodiscard]] friend constexpr auto operator!=(optional const &lhs,
+                                                   optional const &rhs)
+        -> bool {
         return not(lhs == rhs);
     }
 #endif
@@ -224,16 +226,18 @@ template <typename T, typename TS = tombstone_traits<T>> class optional {
                    ? lhs.val < rhs.val
                    : not lhs.has_value() and rhs.has_value();
     }
-    [[nodiscard]] friend constexpr auto
-    operator<=(optional const &lhs, optional const &rhs) -> bool {
+    [[nodiscard]] friend constexpr auto operator<=(optional const &lhs,
+                                                   optional const &rhs)
+        -> bool {
         return not(rhs < lhs);
     }
     [[nodiscard]] friend constexpr auto operator>(optional const &lhs,
                                                   optional const &rhs) -> bool {
         return rhs < lhs;
     }
-    [[nodiscard]] friend constexpr auto
-    operator>=(optional const &lhs, optional const &rhs) -> bool {
+    [[nodiscard]] friend constexpr auto operator>=(optional const &lhs,
+                                                   optional const &rhs)
+        -> bool {
         return not(lhs < rhs);
     }
 };
diff --git a/include/stdx/rollover.hpp b/include/stdx/rollover.hpp
index f6f3585..6e52e37 100644
--- a/include/stdx/rollover.hpp
+++ b/include/stdx/rollover.hpp
@@ -80,34 +80,39 @@ template <typename T> struct rollover_t {
     constexpr friend auto operator>(rollover_t, rollover_t) -> bool = delete;
     constexpr friend auto operator>=(rollover_t, rollover_t) -> bool = delete;
 
-    [[nodiscard]] constexpr friend auto cmp_less(rollover_t lhs,
-                                                 rollover_t rhs) -> bool {
+    [[nodiscard]] constexpr friend auto cmp_less(rollover_t lhs, rollover_t rhs)
+        -> bool {
         constexpr auto mid = static_cast<underlying_t>(~underlying_t{}) / 2;
         return static_cast<underlying_t>(lhs.value - rhs.value) > mid;
     }
 
-    [[nodiscard]] constexpr friend auto
-    operator+(rollover_t lhs, rollover_t rhs) -> rollover_t {
+    [[nodiscard]] constexpr friend auto operator+(rollover_t lhs,
+                                                  rollover_t rhs)
+        -> rollover_t {
         lhs += rhs;
         return lhs;
     }
-    [[nodiscard]] constexpr friend auto
-    operator-(rollover_t lhs, rollover_t rhs) -> rollover_t {
+    [[nodiscard]] constexpr friend auto operator-(rollover_t lhs,
+                                                  rollover_t rhs)
+        -> rollover_t {
         lhs -= rhs;
         return lhs;
     }
-    [[nodiscard]] constexpr friend auto
-    operator*(rollover_t lhs, rollover_t rhs) -> rollover_t {
+    [[nodiscard]] constexpr friend auto operator*(rollover_t lhs,
+                                                  rollover_t rhs)
+        -> rollover_t {
         lhs *= rhs;
         return lhs;
     }
-    [[nodiscard]] constexpr friend auto
-    operator/(rollover_t lhs, rollover_t rhs) -> rollover_t {
+    [[nodiscard]] constexpr friend auto operator/(rollover_t lhs,
+                                                  rollover_t rhs)
+        -> rollover_t {
         lhs /= rhs;
         return lhs;
     }
-    [[nodiscard]] constexpr friend auto
-    operator%(rollover_t lhs, rollover_t rhs) -> rollover_t {
+    [[nodiscard]] constexpr friend auto operator%(rollover_t lhs,
+                                                  rollover_t rhs)
+        -> rollover_t {
         lhs %= rhs;
         return lhs;
     }
diff --git a/include/stdx/span.hpp b/include/stdx/span.hpp
index 96cd061..67bbcee 100644
--- a/include/stdx/span.hpp
+++ b/include/stdx/span.hpp
@@ -159,8 +159,8 @@ class span : public detail::span_base<T, Extent> {
     [[nodiscard]] constexpr auto rbegin() const noexcept -> reverse_iterator {
         return std::reverse_iterator{end()};
     }
-    [[nodiscard]] constexpr auto
-    crbegin() const noexcept -> const_reverse_iterator {
+    [[nodiscard]] constexpr auto crbegin() const noexcept
+        -> const_reverse_iterator {
         return std::reverse_iterator{cend()};
     }
 
@@ -173,8 +173,8 @@ class span : public detail::span_base<T, Extent> {
     [[nodiscard]] constexpr auto rend() const noexcept -> reverse_iterator {
         return std::reverse_iterator{begin()};
     }
-    [[nodiscard]] constexpr auto
-    crend() const noexcept -> const_reverse_iterator {
+    [[nodiscard]] constexpr auto crend() const noexcept
+        -> const_reverse_iterator {
         return std::reverse_iterator{cbegin()};
     }
 
@@ -192,8 +192,8 @@ class span : public detail::span_base<T, Extent> {
         static_assert(Count <= Extent, "first cannot form a larger span!");
         return span<element_type, Count>{ptr, Count};
     }
-    [[nodiscard]] constexpr auto
-    first(size_type count) const -> span<element_type, dynamic_extent> {
+    [[nodiscard]] constexpr auto first(size_type count) const
+        -> span<element_type, dynamic_extent> {
         return {ptr, count};
     }
 
@@ -202,8 +202,8 @@ class span : public detail::span_base<T, Extent> {
         static_assert(Count <= Extent, "last cannot form a larger span!");
         return span<element_type, Count>{ptr + this->size() - Count, Count};
     }
-    [[nodiscard]] constexpr auto
-    last(size_type count) const -> span<element_type, dynamic_extent> {
+    [[nodiscard]] constexpr auto last(size_type count) const
+        -> span<element_type, dynamic_extent> {
         return {ptr + this->size() - count, count};
     }
 
@@ -268,8 +268,8 @@ template <typename R> using range_reference_t = iter_reference_t<iterator_t<R>>;
 } // namespace detail
 
 template <typename It, typename EndOrSize>
-span(It,
-     EndOrSize) -> span<std::remove_reference_t<detail::iter_reference_t<It>>>;
+span(It, EndOrSize)
+    -> span<std::remove_reference_t<detail::iter_reference_t<It>>>;
 // NOLINTNEXTLINE(*-avoid-c-arrays)
 template <typename T, std::size_t N> span(T (&)[N]) -> span<T, N>;
 template <typename T, std::size_t N> span(std::array<T, N> &) -> span<T, N>;
diff --git a/include/stdx/tuple.hpp b/include/stdx/tuple.hpp
index ec06b88..a03135e 100644
--- a/include/stdx/tuple.hpp
+++ b/include/stdx/tuple.hpp
@@ -59,8 +59,9 @@ template <std::size_t Index, typename T, typename... Ts> struct element {
 #else
     constexpr static auto ugly_Value(index_constant<Index>) -> T;
 
-    [[nodiscard]] constexpr auto ugly_iGet_clvr(
-        index_constant<Index>) const & noexcept LIFETIMEBOUND -> T const & {
+    [[nodiscard]] constexpr auto
+    ugly_iGet_clvr(index_constant<Index>) const & noexcept LIFETIMEBOUND
+        -> T const & {
         return value;
     }
     [[nodiscard]] constexpr auto
@@ -75,8 +76,9 @@ template <std::size_t Index, typename T, typename... Ts> struct element {
 
     template <typename U>
         requires(std::same_as<U, T> or ... or std::same_as<U, Ts>)
-    [[nodiscard]] constexpr auto ugly_tGet_clvr(
-        tag_constant<U> *) const & noexcept LIFETIMEBOUND -> T const & {
+    [[nodiscard]] constexpr auto
+    ugly_tGet_clvr(tag_constant<U> *) const & noexcept LIFETIMEBOUND
+        -> T const & {
         return value;
     }
     template <typename U>
@@ -103,8 +105,9 @@ template <std::size_t Index, typename T, typename... Ts> struct element {
     T value;
 
   private:
-    [[nodiscard]] friend constexpr auto
-    operator==(element const &, element const &) -> bool = default;
+    [[nodiscard]] friend constexpr auto operator==(element const &,
+                                                   element const &)
+        -> bool = default;
     [[nodiscard]] friend constexpr auto operator<=>(element const &,
                                                     element const &) = default;
 };
@@ -334,14 +337,14 @@ struct tuple_impl<std::index_sequence<Is...>, index_function_list<Fs...>, Ts...>
     constexpr static auto size =
         std::integral_constant<std::size_t, sizeof...(Ts)>{};
 
-    [[nodiscard]] constexpr static auto
-    fill_inner_indices(index_pair *p) -> index_pair * {
+    [[nodiscard]] constexpr static auto fill_inner_indices(index_pair *p)
+        -> index_pair * {
         ((p++->inner = Is), ...);
         return p;
     }
     [[nodiscard]] constexpr static auto
-    fill_outer_indices(index_pair *p,
-                       [[maybe_unused]] std::size_t n) -> index_pair * {
+    fill_outer_indices(index_pair *p, [[maybe_unused]] std::size_t n)
+        -> index_pair * {
         ((p++->outer = (static_cast<void>(Is), n)), ...);
         return p;
     }
@@ -402,8 +405,8 @@ class tuple : public detail::tuple_impl<std::index_sequence_for<Ts...>,
                                         detail::index_function_list<>, Ts...> {
     template <typename U>
         requires(not tuple_comparable<U>)
-    [[nodiscard]] friend constexpr auto operator==(tuple const &,
-                                                   U const &) -> bool = delete;
+    [[nodiscard]] friend constexpr auto operator==(tuple const &, U const &)
+        -> bool = delete;
 
     template <typename U>
         requires(not tuple_comparable<U>)
@@ -430,14 +433,14 @@ template <typename... Ts>
 indexed_tuple(Ts...) -> indexed_tuple<detail::index_function_list<>, Ts...>;
 
 template <std::size_t I, tuplelike Tuple>
-[[nodiscard]] constexpr auto
-get(Tuple &&t LIFETIMEBOUND) -> decltype(std::forward<Tuple>(t)[index<I>]) {
+[[nodiscard]] constexpr auto get(Tuple &&t LIFETIMEBOUND)
+    -> decltype(std::forward<Tuple>(t)[index<I>]) {
     return std::forward<Tuple>(t)[index<I>];
 }
 
 template <typename T, tuplelike Tuple>
-[[nodiscard]] constexpr auto
-get(Tuple &&t LIFETIMEBOUND) -> decltype(std::forward<Tuple>(t).get(tag<T>)) {
+[[nodiscard]] constexpr auto get(Tuple &&t LIFETIMEBOUND)
+    -> decltype(std::forward<Tuple>(t).get(tag<T>)) {
     return std::forward<Tuple>(t).get(tag<T>);
 }
 
diff --git a/include/stdx/tuple_algorithms.hpp b/include/stdx/tuple_algorithms.hpp
index a2f2ad3..5c302a6 100644
--- a/include/stdx/tuple_algorithms.hpp
+++ b/include/stdx/tuple_algorithms.hpp
@@ -93,14 +93,14 @@ template <tuplelike Tup, typename T>
 }
 
 template <typename T, tuplelike Tup>
-[[nodiscard]] constexpr auto tuple_push_front(T &&t,
-                                              Tup &&tup) -> decltype(auto) {
+[[nodiscard]] constexpr auto tuple_push_front(T &&t, Tup &&tup)
+    -> decltype(auto) {
     return tuple_cons(std::forward<T>(t), std::forward<Tup>(tup));
 }
 
 template <tuplelike Tup, typename T>
-[[nodiscard]] constexpr auto tuple_push_back(Tup &&tup,
-                                             T &&t) -> decltype(auto) {
+[[nodiscard]] constexpr auto tuple_push_back(Tup &&tup, T &&t)
+    -> decltype(auto) {
     return tuple_snoc(std::forward<Tup>(tup), std::forward<T>(t));
 }
 
@@ -280,8 +280,8 @@ template <tuplelike T, template <typename> typename Proj = std::type_identity_t>
 struct chunk {
     std::size_t offset{};
     std::size_t size{};
-    friend constexpr auto operator==(chunk const &,
-                                     chunk const &) -> bool = default;
+    friend constexpr auto operator==(chunk const &, chunk const &)
+        -> bool = default;
 };
 
 template <tuplelike T, template <typename> typename Proj = std::type_identity_t>
diff --git a/include/stdx/type_traits.hpp b/include/stdx/type_traits.hpp
index daa6207..eb4136c 100644
--- a/include/stdx/type_traits.hpp
+++ b/include/stdx/type_traits.hpp
@@ -101,8 +101,8 @@ constexpr bool is_value_specialization_of_v =
     detail::is_value_specialization_of_v<U &, T>;
 
 template <typename U, template <typename...> typename T>
-constexpr auto
-is_specialization_of() -> std::bool_constant<is_specialization_of_v<U, T>> {
+constexpr auto is_specialization_of()
+    -> std::bool_constant<is_specialization_of_v<U, T>> {
     return {};
 }
 
diff --git a/include/stdx/udls.hpp b/include/stdx/udls.hpp
index 11e673d..22a5293 100644
--- a/include/stdx/udls.hpp
+++ b/include/stdx/udls.hpp
@@ -111,29 +111,29 @@ CONSTEVAL auto operator""_false(char const *, std::size_t) -> bool {
 }
 
 // NOLINTBEGIN(google-runtime-int)
-CONSTEVAL auto
-operator""_k(unsigned long long int n) -> unsigned long long int {
+CONSTEVAL auto operator""_k(unsigned long long int n)
+    -> unsigned long long int {
     return n * 1'000u;
 }
-CONSTEVAL auto
-operator""_M(unsigned long long int n) -> unsigned long long int {
+CONSTEVAL auto operator""_M(unsigned long long int n)
+    -> unsigned long long int {
     return n * 1'000'000u;
 }
-CONSTEVAL auto
-operator""_G(unsigned long long int n) -> unsigned long long int {
+CONSTEVAL auto operator""_G(unsigned long long int n)
+    -> unsigned long long int {
     return n * 1'000'000'000u;
 }
 
-CONSTEVAL auto
-operator""_ki(unsigned long long int n) -> unsigned long long int {
+CONSTEVAL auto operator""_ki(unsigned long long int n)
+    -> unsigned long long int {
     return n * 1'024u;
 }
-CONSTEVAL auto
-operator""_Mi(unsigned long long int n) -> unsigned long long int {
+CONSTEVAL auto operator""_Mi(unsigned long long int n)
+    -> unsigned long long int {
     return n * 1'024ull * 1'024ull;
 }
-CONSTEVAL auto
-operator""_Gi(unsigned long long int n) -> unsigned long long int {
+CONSTEVAL auto operator""_Gi(unsigned long long int n)
+    -> unsigned long long int {
     return n * 1'024ull * 1'024ull * 1'024ull;
 }
 
diff --git a/test/detail/tuple_types.hpp b/test/detail/tuple_types.hpp
index c88484d..6dcb823 100644
--- a/test/detail/tuple_types.hpp
+++ b/test/detail/tuple_types.hpp
@@ -6,8 +6,8 @@ struct move_only {
     constexpr move_only(move_only &&) = default;
     constexpr auto operator=(move_only &&) noexcept -> move_only & = default;
 
-    friend constexpr auto operator==(move_only const &lhs,
-                                     move_only const &rhs) -> bool {
+    friend constexpr auto operator==(move_only const &lhs, move_only const &rhs)
+        -> bool {
         return lhs.value == rhs.value;
     }
 
diff --git a/test/optional.cpp b/test/optional.cpp
index 0c406f9..679f370 100644
--- a/test/optional.cpp
+++ b/test/optional.cpp
@@ -332,8 +332,8 @@ struct move_only {
     constexpr move_only(int i) : value{i} {}
     constexpr move_only(move_only &&) = default;
     int value{};
-    constexpr friend auto operator==(move_only const &x,
-                                     move_only const &y) -> bool {
+    constexpr friend auto operator==(move_only const &x, move_only const &y)
+        -> bool {
         return x.value == y.value;
     }
 };
@@ -342,8 +342,8 @@ struct non_movable {
     constexpr non_movable(int i) : value{i} {}
     constexpr non_movable(non_movable &&) = delete;
     int value{};
-    constexpr friend auto operator==(non_movable const &x,
-                                     non_movable const &y) -> bool {
+    constexpr friend auto operator==(non_movable const &x, non_movable const &y)
+        -> bool {
         return x.value == y.value;
     }
 };