Add support for CheckedNumeric Max and Min constexpr functions

base/numerics/safe_conversions_impl.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
 #define BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
 
 #include <limits.h>
 #include <stdint.h>
 
@@ skipping 317 matching lines @@
   static const typename std::enable_if<std::numeric_limits<Integer>::is_integer,
                                        size_t>::type value =
       CHAR_BIT * sizeof(Integer) - 1;
 };
 
 enum ArithmeticPromotionCategory {
   LEFT_PROMOTION,  // Use the type of the left-hand argument.
   RIGHT_PROMOTION  // Use the type of the right-hand argument.
 };
 
-template <ArithmeticPromotionCategory Promotion,
-          typename Lhs,
-          typename Rhs = Lhs>
-struct ArithmeticPromotion;
-
+// Determines the type that can represent the largest positive value.
 template <typename Lhs,
           typename Rhs,
           ArithmeticPromotionCategory Promotion =
               (MaxExponent<Lhs>::value > MaxExponent<Rhs>::value)
                   ? LEFT_PROMOTION
                   : RIGHT_PROMOTION>
 struct MaxExponentPromotion;
 
 template <typename Lhs, typename Rhs>
 struct MaxExponentPromotion<Lhs, Rhs, LEFT_PROMOTION> {
   using type = Lhs;
 };
 
 template <typename Lhs, typename Rhs>
 struct MaxExponentPromotion<Lhs, Rhs, RIGHT_PROMOTION> {
   using type = Rhs;
 };
 
+// Determines the type that can represent the lowest arithmetic value.

[dcheng, 2016/12/03 21:34:29]

Nit: it kind of feels like we should be more consistent about terminology here
and just call this minimum instead of lowest.

[jschuh, 2016/12/03 22:29:12]

I tried to be consistent with std::numeric_limits<> (where the right thing is
max and lowest, not min). I'm not wedded to that approach, but I was going to
replace all the occurrences of -numeric_limits<FLOAT>::max() and
numeric_limits<INTEGER>::min() with numeric_limits<>::lowest(). So, this just
felt more consistent in that world.

+template <typename Lhs,
+          typename Rhs,
+          ArithmeticPromotionCategory Promotion =
+              std::is_signed<Lhs>::value
+                  ? (std::is_signed<Rhs>::value
+                         ? (MaxExponent<Lhs>::value > MaxExponent<Rhs>::value
+                                ? LEFT_PROMOTION
+                                : RIGHT_PROMOTION)
+                         : LEFT_PROMOTION)
+                  : (std::is_signed<Rhs>::value
+                         ? RIGHT_PROMOTION
+                         : (MaxExponent<Lhs>::value < MaxExponent<Rhs>::value
+                                ? LEFT_PROMOTION
+                                : RIGHT_PROMOTION))>
+struct LowestValuePromotion;
+
+template <typename Lhs, typename Rhs>
+struct LowestValuePromotion<Lhs, Rhs, LEFT_PROMOTION> {
+  using type = Lhs;
+};
+
+template <typename Lhs, typename Rhs>
+struct LowestValuePromotion<Lhs, Rhs, RIGHT_PROMOTION> {
+  using type = Rhs;
+};
+
+// Determines the type that is best able to represent an arithmetic result.
 template <typename Lhs,
           typename Rhs = Lhs,
           bool is_intmax_type =
               std::is_integral<
                   typename MaxExponentPromotion<Lhs, Rhs>::type>::value &&
               sizeof(typename MaxExponentPromotion<Lhs, Rhs>::type) ==
                   sizeof(intmax_t),
           bool is_max_exponent =
               StaticDstRangeRelationToSrcRange<
                   typename MaxExponentPromotion<Lhs, Rhs>::type,
@@ skipping 247 matching lines @@
                    static_cast<BigType>(static_cast<L>(lhs)),
                    static_cast<BigType>(static_cast<R>(rhs)))
              // Let the template functions figure it out for mixed types.
              : C<L, R>::Test(lhs, rhs);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_