Put many implementation details in unnamed namespace to work around llvm/llvm-project#90154

Author: davidstone

source/bounded/arithmetic/increment_decrement.cpp

@@ -23,6 +23,8 @@ namespace bounded {
 OPERATORS_IMPORT_COMPOUND_ASSIGNMENT(export)
 export using operators::binary::operator-; \
 
+namespace {
+
 template<typename T>
 concept incrementable_by_bounded = requires(T value) {
 	value += constant<1>;
@@ -32,6 +34,8 @@ concept decrementable_by_bounded = requires(T value) {
 	value -= constant<1>;
 };
 
+} // namespace
+
 inline namespace arithmetic {
 
 export constexpr auto operator++(incrementable_by_bounded auto & value) -> decltype(auto) {

source/bounded/arithmetic/modulus.cpp

@@ -21,6 +21,7 @@ import std_module;
 
 namespace bounded {
 
+namespace {
 
 using smax_t = numeric_traits::max_signed_t;
 using umax_t = numeric_traits::max_unsigned_t;
@@ -78,6 +79,8 @@ constexpr auto sign_free_value = [](auto const dividend, auto divisor) {
 	return current;
 };
 
+} // namespace
+
 constexpr auto modulus_operator_range(auto const lhs, auto const rhs) {
 	// The sign of the result is equal to the sign of the lhs. The sign of the
 	// rhs does not matter. Therefore, we use the absolute value of the rhs; we

source/bounded/arithmetic/operators.cpp

@@ -39,6 +39,8 @@ BOUNDED_COMMON_ARITHMETIC(export)
 
 } // namespace bounded
 
+namespace {
+
 static_assert(homogeneous_equals(
 	bounded::constant<0> - bounded::constant<0>,
 	bounded::constant<0>
@@ -88,4 +90,6 @@ static_assert([]{
 	BOUNDED_ASSERT(post_increment == bounded::constant<0>);
 	BOUNDED_ASSERT(z == bounded::constant<1>);
 	return true;
-}());
+}());
+
+} // namespace

source/bounded/arithmetic/operators_builtin.cpp

@@ -45,6 +45,8 @@ BOUNDED_INTEGER_MIXED_OPERATOR_OVERLOADS(>>)
 
 } // namespace bounded
 
+namespace {
+
 static_assert(homogeneous_equals(
 	bounded::integer<1, 10>(bounded::constant<9>) + std::integral_constant<int, 5>{},
 	bounded::integer<6, 15>(bounded::constant<14>)
@@ -106,3 +108,5 @@ static_assert(plus_equals(9U, bounded::constant<3>) == 12);
 static_assert(minus_equals(9, bounded::constant<68>) == -59);
 static_assert(divides_equals(-59, bounded::constant<10>) == -5);
 static_assert(modulus_equals(-5, bounded::constant<4>) == -1);
+
+} // namespace

source/bounded/arithmetic/plus.cpp

@@ -18,8 +18,12 @@ import std_module;
 
 namespace bounded {
 
+namespace {
+
 constexpr auto max_signed = numeric_traits::max_value<numeric_traits::max_signed_t>;
 
+} // namespace
+
 template<auto lhs, auto rhs>
 constexpr auto safer_add() {
 	constexpr auto modulo_equivalent_value = static_cast<numeric_traits::max_unsigned_t>(lhs) + static_cast<numeric_traits::max_unsigned_t>(rhs);

source/bounded/arithmetic/pointer.cpp

@@ -15,13 +15,17 @@ import std_module;
 
 namespace bounded {
 
+namespace {
+
 // This is faster to compile than `std::is_pointer_v`
 template<typename>
 constexpr auto is_pointer = false;
 
 template<typename T>
 constexpr auto is_pointer<T *> = true;
 
+} // namespace
+
 export template<typename T, bounded_integer Integer> requires(
 	(is_pointer<T> or (std::is_array_v<T> and numeric_traits::max_value<Integer> <= constant<std::extent_v<T>>))
 )
@@ -42,6 +46,8 @@ constexpr auto operator+(Integer const number, T const & array) {
 
 } // namespace bounded
 
+namespace {
+
 using array_type = int[5];
 constexpr array_type array{ 0, 1, 2, 3, 4 };
 
@@ -71,3 +77,5 @@ static_assert(
 	"Incorrect array indexing with bounded::integer."
 );
 #endif
+
+} // namespace

source/bounded/arithmetic/unary_minus.cpp

@@ -47,6 +47,8 @@ constexpr auto operator-(integer<minimum, maximum> const value) {
 
 } // namespace bounded
 
+namespace {
+
 static_assert(homogeneous_equals(
 	-bounded::constant<0>,
 	bounded::constant<0>
@@ -102,4 +104,6 @@ static_assert(homogeneous_equals(
 static_assert(homogeneous_equals(
 	-bounded::integer<-3, 6>(bounded::constant<4>),
 	bounded::integer<-6, 3>(bounded::constant<-4>)
-));
+));
+
+} // namespace

source/bounded/arithmetic/unary_plus.cpp

@@ -18,6 +18,8 @@ export constexpr auto operator+(bounded_integer auto const value) {
 
 } // namespace bounded
 
+namespace {
+
 static_assert(homogeneous_equals(
 	+bounded::constant<0>,
 	bounded::constant<0>
@@ -44,3 +46,5 @@ static_assert(homogeneous_equals(
 	+x,
 	x
 ));
+
+} // namespace

source/bounded/construct.cpp

@@ -28,6 +28,8 @@ constexpr auto construct = construct_t<T>();
 
 } // namespace bounded
 
+namespace {
+
 static_assert(bounded::construct<int>() == 0);
 static_assert(bounded::construct<int>(2) == 2);
 static_assert(noexcept(bounded::construct<int>()));
@@ -43,3 +45,5 @@ struct convert_to_int_throws {
 };
 
 static_assert(!noexcept(bounded::construct<int>(convert_to_int_throws())));
+
+} // namespace

source/bounded/construct_at.cpp

@@ -70,6 +70,8 @@ export constexpr auto construct_at = construct_at_t();
 
 } // namespace bounded
 
+namespace {
+
 struct empty {};
 
 struct accepts_anything {
@@ -115,3 +117,4 @@ static_assert(!noexcept(bounded::construct_at(bounded::declval<int &>(), make_no
 auto make_no_lazy_construction_convert_to_int_throws() noexcept -> bounded::no_lazy_construction<convert_to_int_throws>;
 static_assert(!noexcept(bounded::construct_at(bounded::declval<int &>(), make_no_lazy_construction_convert_to_int_throws)));
 
+} // namespace

source/bounded/safe_compare.cpp

@@ -13,8 +13,12 @@ import std_module;
 
 namespace bounded {
 
+namespace {
+
 constexpr auto max_signed = numeric_traits::max_value<numeric_traits::max_signed_t>;
 
+} // namespace
+
 export template<builtin_integer LHS, builtin_integer RHS>
 constexpr auto safe_compare(LHS const lhs, RHS const rhs) -> std::strong_ordering {
 	if constexpr (signed_builtin<LHS> == signed_builtin<RHS>) {

source/bounded/safe_equal.cpp

@@ -13,8 +13,12 @@ import std_module;
 
 namespace bounded {
 
+namespace {
+
 constexpr auto max_signed = numeric_traits::max_value<numeric_traits::max_signed_t>;
 
+} // namespace
+
 export template<builtin_integer LHS, builtin_integer RHS>
 constexpr auto safe_equal(LHS const lhs, RHS const rhs) -> bool {
 	if constexpr (signed_builtin<LHS> == signed_builtin<RHS>) {

source/containers/array.cpp

@@ -170,6 +170,7 @@ struct std::tuple_element<index, ::containers::array<T, size>> {
 	using type = T;
 };
 
+namespace {
 
 constexpr auto size = 5_bi;
 constexpr containers::array<int, size> a = {};
@@ -224,3 +225,5 @@ static_assert(array_non_copyable_empty.size() == 0_bi);
 constexpr auto large_size = 10000_bi;
 constexpr auto large_array_n = containers::make_array_n(large_size, 0);
 static_assert(large_array_n.size() == large_size);
+
+} // namespace

source/containers/begin_end.cpp

@@ -65,6 +65,7 @@ constexpr auto end(Range && r) {
 }
 
 } // namespace containers
+namespace {
 
 using namespace bounded::literal;
 
@@ -112,3 +113,5 @@ struct {
 	}
 } constexpr data_and_size;
 static_assert(containers::begin(data_and_size) == containers::end(data_and_size));
+
+} // namespace

source/containers/size.cpp

@@ -37,7 +37,7 @@ constexpr auto size(c_array<T, size_> const &) {
 }
 
 } // namespace containers
-
+namespace {
 using namespace bounded::literal;
 
 constexpr int a[] = {0, 1, 2, 3, 4};
@@ -84,4 +84,6 @@ struct member_begin_end {
 		return begin() + 4;
 	}
 };
-static_assert(containers::size(member_begin_end()) == 4);
+static_assert(containers::size(member_begin_end()) == 4);
+
+} // namespace