[ADT] Simplify getAsInteger (NFC)

[kazu]

Summary

This patch replaces the std::enable_if_t trick with a "constexpr if"
so that the resulting code looks more like "normal" C++ code.

[dblaikie]

Sounds good to me, thanks!

llvm/include/llvm/ADT/StringRef.h

#endif
 
     /// Parse the current string as an integer of the specified radix.  If
     /// \p Radix is specified as zero, this does radix autosensing using
     /// extended C rules: 0 is octal, 0x is hex, 0b is binary.
     ///
     /// If the string is invalid or if only a subset of the string is valid,
     /// this returns true to signify the error.  The string is considered
     /// erroneous if empty or if it overflows T.
-    template <typename T>
-    std::enable_if_t<std::numeric_limits<T>::is_signed, bool>
-    getAsInteger(unsigned Radix, T &Result) const {
+    template <typename T> bool getAsInteger(unsigned Radix, T &Result) const {
+      if constexpr (std::numeric_limits<T>::is_signed) {
         long long LLVal;
         if (getAsSignedInteger(*this, Radix, LLVal) ||
             static_cast<T>(LLVal) != LLVal)
           return true;
         Result = LLVal;
-      return false;
-    }
-
-    template <typename T>
-    std::enable_if_t<!std::numeric_limits<T>::is_signed, bool>
-    getAsInteger(unsigned Radix, T &Result) const {
+      } else {
         unsigned long long ULLVal;
         // The additional cast to unsigned long long is required to avoid the
         // Visual C++ warning C4805: '!=' : unsafe mix of type 'bool' and type
         // 'unsigned __int64' when instantiating getAsInteger with T = bool.
         if (getAsUnsignedInteger(*this, Radix, ULLVal) ||
             static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal)
           return true;
         Result = ULLVal;
+      }
       return false;
     }
 
     /// Parse the current string as an integer of the specified radix.  If
     /// \p Radix is specified as zero, this does radix autosensing using
     /// extended C rules: 0 is octal, 0x is hex, 0b is binary.
     ///
     /// If the string does not begin with a number of the specified radix,
     /// this returns true to signify the error. The string is considered
     /// erroneous if empty or if it overflows T.
     /// The portion of the string representing the discovered numeric value
     /// is removed from the beginning of the string.
-    template <typename T>
-    std::enable_if_t<std::numeric_limits<T>::is_signed, bool>
-    consumeInteger(unsigned Radix, T &Result) {
+    template <typename T> bool consumeInteger(unsigned Radix, T &Result) {
+      if constexpr (std::numeric_limits<T>::is_signed) {
         long long LLVal;
         if (consumeSignedInteger(*this, Radix, LLVal) ||
             static_cast<long long>(static_cast<T>(LLVal)) != LLVal)
           return true;
         Result = LLVal;
-      return false;
-    }
-
-    template <typename T>
-    std::enable_if_t<!std::numeric_limits<T>::is_signed, bool>
-    consumeInteger(unsigned Radix, T &Result) {
+      } else {
         unsigned long long ULLVal;
         if (consumeUnsignedInteger(*this, Radix, ULLVal) ||
             static_cast<unsigned long long>(static_cast<T>(ULLVal)) != ULLVal)
           return true;
         Result = ULLVal;
+      }
       return false;
     }
 
     /// Parse the current string as an integer of the specified \p Radix, or of
     /// an autosensed radix if the \p Radix given is 0.  The current value in
     /// \p Result is discarded, and the storage is changed to be wide enough to
     /// store the parsed integer.
     ///