Support SFINAE in Constant representability check (#669)

Right now, we have an unconditional `UnitRatio` invocation, which
produces a hard compiler error.  We thought this was fine, because
nobody should be invoking this check with different-dimension units.
However, it somehow does get invoked in Aurora-internal code.

I tried reproducing the error in the Au repo only, and couldn't do it.
But in any case, we can fix it by just avoiding the hard error.

The most straightforward way to fix it was to just make a new trait,
`IsUnitRatioRepresentableIn<T, U1, U2>`.  This doesn't seem like
something I want to expose to end users, so I kept it as a library
internal detail.

Author: chiphogg

au/constant.hh

@@ -109,8 +109,8 @@ struct Constant : detail::MakesQuantityFromNumber<Constant, Unit>,
     // Static function to check whether this constant can be exactly-represented in the given rep
     // `T` and unit `OtherUnit`.
     template <typename T, typename OtherUnit>
-    static constexpr bool can_store_value_in(OtherUnit other) {
-        return representable_in<T>(unit_ratio(Unit{}, other));
+    static constexpr bool can_store_value_in(OtherUnit) {
+        return detail::IsUnitRatioRepresentableIn<T, Unit, AssociatedUnit<OtherUnit>>::value;
     }
 
     // Implicitly convert to type with an exactly corresponding quantity that passes safety checks.

au/constant_test.cc

@@ -437,6 +437,11 @@ TEST(CanStoreValueIn, ChecksRangeOfTypeForIntegers) {
     EXPECT_THAT(decltype(c)::can_store_value_in<int16_t>(meters / second), IsFalse());
 }
 
+TEST(CanStoreValueIn, ReturnsFalseRatherThanHardErrorForDifferentDimensions) {
+    constexpr bool result = Constant<Meters>::can_store_value_in<long>(Nano<Seconds>{});
+    EXPECT_THAT(result, IsFalse());
+}
+
 TEST(Constant, SupportsEqualityComparison) {
     constexpr auto one_meter = make_constant(meters);
     constexpr auto another_meter = make_constant(meters);

au/unit_of_measure.hh

@@ -482,6 +482,15 @@ constexpr auto pow(SingularNameFor<Unit>) {
 template <typename U>
 struct UnitOrderTiebreaker;
 
+// Library-internal helper to check representability of ratio between two units in a numeric type.
+//
+// This will return `false` (rather than producing a compiler error) if the units don't have the
+// same dimension.
+namespace detail {
+template <typename T, typename U1, typename U2>
+struct IsUnitRatioRepresentableIn;
+}  // namespace detail
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Implementation details below
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1385,4 +1394,22 @@ struct InOrderFor<UnitSumPack, A, B>
                                  detail::OrderByUnscaledUnit,
                                  detail::OrderByMag> {};
 
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// `IsUnitRatioRepresentableIn` implementation.
+
+namespace detail {
+// Helper simply delegates to `representable_in` in the usual case.
+template <typename T, typename U1, typename U2, bool SameDim = HasSameDimension<U1, U2>::value>
+struct IsUnitRatioRepresentableInImpl
+    : stdx::bool_constant<representable_in<T>(UnitRatio<U1, U2>{})> {};
+
+// If dimensions differ, just return false.
+template <typename T, typename U1, typename U2>
+struct IsUnitRatioRepresentableInImpl<T, U1, U2, false> : std::false_type {};
+
+// Delegate to the appropriate helper.
+template <typename T, typename U1, typename U2>
+struct IsUnitRatioRepresentableIn : IsUnitRatioRepresentableInImpl<T, U1, U2> {};
+}  // namespace detail
+
 }  // namespace au

au/unit_of_measure_test.cc

@@ -21,6 +21,7 @@
 #include "au/testing.hh"
 #include "au/units/fahrenheit.hh"
 #include "au/units/feet.hh"
+#include "au/units/hertz.hh"
 #include "au/units/inches.hh"
 #include "au/units/kelvins.hh"
 #include "au/units/meters.hh"
@@ -1142,5 +1143,25 @@ TEST(SimplifyIfOnlyOneUnscaledUnit, IdentityForNonCommonUnit) {
                        decltype(Feet{} * mag<3>())>();
 }
 
+TEST(IsUnitRatioRepresentableIn, TrueForIdentityRatio) {
+    EXPECT_THAT((IsUnitRatioRepresentableIn<int, Meters, Meters>::value), IsTrue());
+}
+
+TEST(IsUnitRatioRepresentableIn, TrueForRepresentableRatio) {
+    EXPECT_THAT((IsUnitRatioRepresentableIn<int, Feet, Inches>::value), IsTrue());
+}
+
+TEST(IsUnitRatioRepresentableIn, FalseForNonRepresentableRatio) {
+    EXPECT_THAT((IsUnitRatioRepresentableIn<int, Inches, Feet>::value), IsFalse());
+}
+
+TEST(IsUnitRatioRepresentableIn, FalseForOverflowingRatio) {
+    EXPECT_THAT((IsUnitRatioRepresentableIn<int, Tera<Hertz>, Hertz>::value), IsFalse());
+}
+
+TEST(IsUnitRatioRepresentableIn, FalseRatherThanHardErrorForDifferentDimensions) {
+    EXPECT_THAT((IsUnitRatioRepresentableIn<int, Meters, Minutes>::value), IsFalse());
+}
+
 }  // namespace detail
 }  // namespace au