[ADANDONED] Helper code for finding problematic uses of IntToString variants.

base/strings/string_number_conversions.h

 // Copyright (c) 2012 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_STRINGS_STRING_NUMBER_CONVERSIONS_H_
 #define BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
 
 #include <string>
 #include <vector>
 
+#if defined(STRING_NUMBER_CONVERSIONS_DETECT_RISKY_CONVERSIONS)
+#include <limits>
+#include <type_traits>
+#endif
+
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 
 // ----------------------------------------------------------------------------
 // IMPORTANT MESSAGE FROM YOUR SPONSOR
 //
 // This file contains no "wstring" variants. New code should use string16. If
 // you need to make old code work, use the UTF8 version and convert. Please do
 // not add wstring variants.
 //
 // Please do not add "convenience" functions for converting strings to integers
 // that return the value and ignore success/failure. That encourages people to
 // write code that doesn't properly handle the error conditions.
 // ----------------------------------------------------------------------------
 
 namespace base {
 
 // Number -> string conversions ------------------------------------------------
 
+#if defined(STRING_NUMBER_CONVERSIONS_DETECT_RISKY_CONVERSIONS)
+namespace internal {
+#endif
+
 BASE_EXPORT std::string IntToString(int value);
 BASE_EXPORT string16 IntToString16(int value);
 
 BASE_EXPORT std::string UintToString(unsigned value);
 BASE_EXPORT string16 UintToString16(unsigned value);
 
 BASE_EXPORT std::string Int64ToString(int64 value);
 BASE_EXPORT string16 Int64ToString16(int64 value);
 
 BASE_EXPORT std::string Uint64ToString(uint64 value);
 BASE_EXPORT string16 Uint64ToString16(uint64 value);
 
 BASE_EXPORT std::string SizeTToString(size_t value);
 BASE_EXPORT string16 SizeTToString16(size_t value);
 
 // DoubleToString converts the double to a string format that ignores the
 // locale. If you want to use locale specific formatting, use ICU.
 BASE_EXPORT std::string DoubleToString(double value);
 
+#if defined(STRING_NUMBER_CONVERSIONS_DETECT_RISKY_CONVERSIONS)
+}  // namespace internal
+#endif
+
 // String -> number conversions ------------------------------------------------
 
 // Perform a best-effort conversion of the input string to a numeric type,
 // setting |*output| to the result of the conversion.  Returns true for
 // "perfect" conversions; returns false in the following cases:
 //  - Overflow. |*output| will be set to the maximum value supported
 //    by the data type.
 //  - Underflow. |*output| will be set to the minimum value supported
 //    by the data type.
 //  - Trailing characters in the string after parsing the number.  |*output|
@@ skipping 62 matching lines @@
 // The string is not required to start with 0x.
 BASE_EXPORT bool HexStringToUInt64(const StringPiece& input, uint64* output);
 
 // Similar to the previous functions, except that output is a vector of bytes.
 // |*output| will contain as many bytes as were successfully parsed prior to the
 // error.  There is no overflow, but input.size() must be evenly divisible by 2.
 // Leading 0x or +/- are not allowed.
 BASE_EXPORT bool HexStringToBytes(const std::string& input,
                                   std::vector<uint8>* output);
 
+// Detection of potentially risky conversions. This is not enabled by default
+// because it has too many false positives.
+//
+// How to use:
+// 1. Define STRING_NUMBER_CONVERSIONS_DETECT_RISKY_CONVERSIONS (probably the
+//    easiest way is to make a local modification to this file, but make sure
+//    you don't check it in).
+// 2. Compile the code you want to check.
+// 3. You will see errors like "error: temporary of type
+//    'SignedUnsignedMismatch' (aka 'base::ErrorOnUse') has private destructor"
+// 4. Check the actual type of the variable being passed in.
+// 5. Attempt to determine whether the "wrong" conversion function is being used
+//    intentionally. Pay particular attention to 32-bit/64-bit issues and
+//    cross-platform compatibility.
+// 6. Decide if it would be better to use a different conversion function.
+// 7. If so, make the change, compile it, and test it.
+//
+#if defined(STRING_NUMBER_CONVERSIONS_DETECT_RISKY_CONVERSIONS)
+
+// Enums are weird. They have an "underlying type", but that is
+// implementation-specific (unless explicitly specified). However, the overload
+// resolution order for enums *is* specified in the standard, specifically:
+//
+// """ A prvalue of an unscoped enumeration type whose underlying type is not
+// fixed (7.2) can be converted to a prvalue of the first of the following types
+// that can represent all the values of the enumeration (i.e., the values in the
+// range b min to b max as described in 7.2): int, unsigned int, long int,
+// unsigned long int, long long int, or unsigned long long int. """
+//
+// Since that is portable, decide the correct function to pass an enum to based
+// on overload resolution.
+template <typename T>
+class EnumOverloadOrOriginalType {
+ private:
+  template <typename T2, bool is_enum>
+  struct Impl;
+
+  template <typename T2>
+  struct Impl<T2, false> {
+    typedef T2 type;
+  };
+
+  template <typename T2>
+  struct Impl<T2, true> {
+    static int deduce(int);
+    static uint32 deduce(uint32);
+    static int64 deduce(int64);
+    static uint64 deduce(uint64);
+
+    typedef decltype(deduce(T2())) type;
+  };
+
+ public:
+  typedef typename Impl<T, std::is_enum<T>::value>::type type;
+};
+
+template <typename ReturnType,
+          typename ExpectedType,
+          ReturnType(Function)(ExpectedType)>
+struct LooseMatchFunctor {
+  constexpr LooseMatchFunctor() {}
+
+  template <typename T>
+  ReturnType operator()(T value) const {
+    static_assert(
+        std::is_arithmetic<T>::value || std::is_enum<T>::value,
+        "Type passed to numeric conversions must be arithmetic or enum");
+    // If T is an enum, then it is the underlying type we are interested in.
+    typedef typename EnumOverloadOrOriginalType<T>::type ActualType;
+    static_assert(std::is_arithmetic<ActualType>::value,
+                  "ActualType must be arithmetic");
+    static_assert(sizeof(ActualType) <= sizeof(ExpectedType),
+                  "Silent truncation of larger integer type");
+    static_assert(std::is_enum<ActualType>::value ||
+                  std::numeric_limits<ActualType>::is_signed ==
+                      std::numeric_limits<ExpectedType>::is_signed,
+                  "Signed/unsigned mismatch");
+    static_assert(std::is_enum<ActualType>::value ||
+                  std::numeric_limits<ActualType>::is_integer ==
+                      std::numeric_limits<ExpectedType>::is_integer,
+                  "Integer/floating point mismatch");
+    return Function(value);
+  }
+};
+
+template <typename ReturnType,
+          typename ExpectedType,
+          ReturnType(Function)(ExpectedType)>
+struct ExactMatchFunctor {
+  constexpr ExactMatchFunctor() {}
+
+  template <typename ActualType>
+  ReturnType operator()(ActualType value) const {
+    static_assert(std::is_same<ActualType, ExpectedType>::value,
+                  "Types do not match");
+    return Function(value);
+  }
+};
+
+#define DEFINE_INT_TO_STRING_FUNCTION(RETURN_TYPE, EXPECTED_TYPE, FUNCTION)   \
+  constexpr LooseMatchFunctor<RETURN_TYPE, EXPECTED_TYPE, internal::FUNCTION> \
+      FUNCTION
+
+#define DEFINE_EXACT_MATCH_INT_TO_STRING_FUNCTION(RETURN_TYPE, EXPECTED_TYPE, \
+                                                  FUNCTION)                   \
+  constexpr ExactMatchFunctor<RETURN_TYPE, EXPECTED_TYPE, internal::FUNCTION> \
+      FUNCTION
+
+DEFINE_INT_TO_STRING_FUNCTION(std::string, int, IntToString);
+DEFINE_INT_TO_STRING_FUNCTION(string16, int, IntToString16);
+DEFINE_INT_TO_STRING_FUNCTION(std::string, uint32, UintToString);
+DEFINE_INT_TO_STRING_FUNCTION(string16, uint32, UintToString16);
+DEFINE_INT_TO_STRING_FUNCTION(std::string, int64, Int64ToString);
+DEFINE_INT_TO_STRING_FUNCTION(string16, int64, Int64ToString16);
+DEFINE_INT_TO_STRING_FUNCTION(std::string, uint64, Uint64ToString);
+DEFINE_INT_TO_STRING_FUNCTION(string16, uint64, Uint64ToString16);
+DEFINE_EXACT_MATCH_INT_TO_STRING_FUNCTION(std::string, size_t, SizeTToString);
+DEFINE_EXACT_MATCH_INT_TO_STRING_FUNCTION(string16, size_t, SizeTToString16);
+DEFINE_INT_TO_STRING_FUNCTION(std::string, double, DoubleToString);
+
+#endif
+
 }  // namespace base
 
 #endif  // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_