replace use of assert macro

.clang-tidy

@@ -13,9 +13,6 @@ Checks: >
     # Bazel does this for determinism,
     -clang-diagnostic-builtin-macro-redefined,
 
-    # suppress due to assert,
-    -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-
     # short names are fine for short lifetimes,
     -readability-identifier-length,
 

rigid_geometric_algebra/blade_type_from.hpp

@@ -3,9 +3,9 @@
 #include "rigid_geometric_algebra/algebra_type.hpp"
 #include "rigid_geometric_algebra/blade.hpp"
 #include "rigid_geometric_algebra/blade_ordering.hpp"
+#include "rigid_geometric_algebra/detail/contract.hpp"
 
 #include <array>
-#include <cassert>
 #include <cstddef>
 #include <utility>
 
@@ -30,12 +30,12 @@ struct blade_type_from
 
       for (auto index = 0UZ; index != mask.size(); ++index) {
         if (mask.test(index)) {
-          assert(it != dims.end());
+          detail::invariant(it != dims.end());
           *it++ = index;
         }
       }
-      assert(it == dims.end());
 
+      detail::postcondition(it == dims.end());
       return dims;
     }();
 

rigid_geometric_algebra/detail/array_subset.hpp

@@ -1,7 +1,8 @@
 #pragma once
 
+#include "rigid_geometric_algebra/detail/contract.hpp"
+
 #include <array>
-#include <cassert>
 #include <cstddef>
 #include <ranges>
 
@@ -26,7 +27,7 @@ class array_subset
   constexpr array_subset(const base_type& base, std::size_t size)
       : base_{base}, size_{size}
   {
-    assert(size_ <= Capacity);
+    detail::precondition(size_ <= Capacity);
   }
 
   constexpr auto begin() const noexcept { return base_.begin(); }

rigid_geometric_algebra/detail/contract.hpp

@@ -24,6 +24,12 @@
   explicit precondition_contract() = default;
 };
 
+struct invariant_contract
+{
+  static constexpr auto name = "INVARIANT";
+  explicit invariant_contract() = default;
+};
+
 struct postcondition_contract
 {
   static constexpr auto name = "POSTCONDITION";
@@ -137,6 +143,40 @@
 
 /// @}
 
+/// check an invariant, optionally printing a message on failure
+/// @param cond boolean-convertible value
+/// @param violation_handler handler to invoke on contract violation.
+/// @param sl source location
+///
+/// Check invariant `cond`. If `false`, invoke `handler(sl)`.
+///
+/// @{
+
+template <class Handler>
+  requires std::is_invocable_v<
+      const Handler&,
+      invariant_contract,
+      const std::source_location&>
+constexpr auto invariant(
+    const std::convertible_to<bool> auto& cond,
+    const Handler& violation_handler,
+    const std::source_location& sl = std::source_location::current()) -> void
+{
+  if (cond) {
+    return;
+  }
+
+  violation_handler(invariant_contract{}, sl);
+}
+
+constexpr auto invariant(
+    const std::convertible_to<bool> auto& cond,
+    std::format_string<> message = "",  // NOLINT(misc-include-cleaner)
+    const std::source_location& sl = std::source_location::current()) -> void
+{
+  return invariant(cond, contract_violation_handler{message}, sl);
+}
+
 /// check a postcondition, optionally printing a message on failure
 /// @param cond boolean-convertible value
 /// @param violation_handler handler to invoke on contract violation.

rigid_geometric_algebra/detail/disjoint_subset.hpp

@@ -5,7 +5,6 @@
 
 #include <algorithm>
 #include <array>
-#include <cassert>
 #include <cstddef>
 #include <functional>
 #include <ranges>

rigid_geometric_algebra/detail/structural_bitset.hpp

@@ -3,7 +3,6 @@
 #include "rigid_geometric_algebra/detail/contract.hpp"
 
 #include <bit>
-#include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>

rigid_geometric_algebra/detail/swaps_to_sorted_dimensions.hpp

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <array>
-#include <cassert>
 #include <concepts>
 #include <cstddef>
 #include <functional>

test/complement_test.cpp

@@ -87,6 +87,8 @@ auto main() -> int
     using ::SymEngine::Expression;
 
     const auto abs = []<class T>(T&& arg) -> Expression {
+      // string literal decays to pointer
+      // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
       return {::SymEngine::abs(Expression{std::forward<T>(arg)})};
     };
 

test/detail/define_prioritized_overload_test.cpp

@@ -6,7 +6,6 @@
 #include "rigid_geometric_algebra/detail/priority_list.hpp"
 #include "skytest/skytest.hpp"
 
-#include <cassert>
 #include <cstddef>
 #include <cstdlib>
 #include <type_traits>