test: compile quantity_test.cpp with -DUNITS_DOWNCAST_MODE=0

src/include/units/bits/external/hacks.h

@@ -60,7 +60,7 @@ namespace std {
 template<class T>
 concept default_constructible = constructible_from<T>;
 
-#elif COMP_CLANG
+#elif !COMP_CLANG
 
 // concepts
 using concepts::three_way_comparable;

src/include/units/one_rep.h

@@ -82,9 +82,10 @@ struct one_rep {
   template<QuantityValue Rep>
   [[nodiscard]] friend constexpr Rep operator/(one_rep, const Rep&) = delete;
 
-  template<QuantityValue Rep>
+  template<typename Rep>
   [[nodiscard]] constexpr operator Rep() const noexcept
   {
+    static_assert(QuantityValue<Rep>);
     return quantity_values<Rep>::one();
   }
 

src/include/units/quantity.h

@@ -50,7 +50,7 @@ template<typename QFrom, typename QTo>
 concept harmonic_ = // exposition only
     Quantity<QFrom> &&
     Quantity<QTo> &&
-    requires(QFrom from, QTo to) { requires is_integral(detail::quantity_ratio(from) / detail::quantity_ratio(to)); };
+    is_integral(detail::quantity_ratio<QFrom> / detail::quantity_ratio<QTo>);
 
 template<typename QFrom, typename QTo>
 concept safe_castable_to_ = // exposition only
@@ -136,6 +136,11 @@ public:
   constexpr explicit(!(is_same_v<dimension, dim_one> && is_same_v<unit, ::units::one>))
   quantity(const Value& v) : value_(v) {}
 
+  template<safe_convertible_to_<rep> Value>
+    requires is_same_v<dimension, unknown_dimension<>>
+  constexpr explicit(!(is_same_v<dimension, unknown_dimension<>> && unit::ratio == ratio{1, 1, 0}))
+  quantity(const Value& v) : value_(v) {}
+
   template<safe_castable_to_<quantity> Q>
   constexpr explicit(false) quantity(const Q& q) : value_(quantity_cast<quantity>(q).count()) {}
 
@@ -269,30 +274,30 @@ public:
   // Below friend functions are to be found via argument-dependent lookup only
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator+(const quantity& lhs, const Value& rhs)
-    requires (!Quantity<Value>) && is_same_v<unit, units::one> &&
-          invoke_result_convertible_to_<rep, std::plus<>, rep, Value>
+    requires requires { requires !Quantity<Value>; requires is_same_v<unit, units::one>;
+          requires invoke_result_convertible_to_<rep, std::plus<>, rep, Value>; }
   {
     return units::quantity(lhs.count() + rhs);
   }
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator+(const Value& lhs, const quantity& rhs)
-    requires (!Quantity<Value>) && is_same_v<unit, units::one> &&
-          invoke_result_convertible_to_<rep, std::plus<>, Value, rep>
+    requires requires { requires !Quantity<Value>; requires is_same_v<unit, units::one>;
+          requires invoke_result_convertible_to_<rep, std::plus<>, Value, rep>; }
   {
     return units::quantity(lhs + rhs.count());
   }
 
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator-(const quantity& lhs, const Value& rhs)
-    requires (!Quantity<Value>) && is_same_v<unit, units::one> &&
-          invoke_result_convertible_to_<rep, std::minus<>, rep, Value>
+    requires requires { requires !Quantity<Value>; requires is_same_v<unit, units::one>;
+          requires invoke_result_convertible_to_<rep, std::minus<>, rep, Value>; }
   {
     return units::quantity(lhs.count() - rhs);
   }
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator-(const Value& lhs, const quantity& rhs)
-    requires (!Quantity<Value>) && is_same_v<unit, units::one> &&
-          invoke_result_convertible_to_<rep, std::minus<>, Value, rep>
+    requires requires { requires !Quantity<Value>; requires is_same_v<unit, units::one>;
+          requires invoke_result_convertible_to_<rep, std::minus<>, Value, rep>; }
   {
     return units::quantity(lhs - rhs.count());
   }

src/include/units/quantity_cast.h

@@ -50,8 +50,11 @@ class quantity_point_kind;
 
 namespace detail {
 
+template<typename T>
+  inline constexpr ratio quantity_ratio = std::enable_if_t<!Quantity<T>>{};
+
 template<typename D, typename U, typename Rep>
-constexpr auto quantity_ratio(const quantity<D, U, Rep>&)
+inline constexpr ratio quantity_ratio<quantity<D, U, Rep>> = []
 {
   if constexpr(BaseDimension<D>) {
     return U::ratio;
@@ -59,18 +62,18 @@ constexpr auto quantity_ratio(const quantity<D, U, Rep>&)
   else {
     return D::base_units_ratio * U::ratio / D::coherent_unit::ratio;
   }
-}
+}();
 
-template<typename Q1, typename Q2>
-constexpr ratio cast_ratio(const Q1& from, const Q2& to)
+template<typename QFrom, typename QTo>
+constexpr ratio cast_ratio(const QFrom& from, const QTo& to)
 {
-  using FromU = TYPENAME Q1::unit;
-  using ToU = TYPENAME Q2::unit;
+  using FromU = TYPENAME QFrom::unit;
+  using ToU = TYPENAME QTo::unit;
   if constexpr(same_unit_reference<FromU, ToU>::value) {
     return FromU::ratio / ToU::ratio;
   }
   else {
-    return quantity_ratio(from) / quantity_ratio(to);
+    return quantity_ratio<QFrom> / quantity_ratio<QTo>;
   }
 }