Replaced all instances of Simple{IDF}toa with StrCat.

This makes for easier rewrites between internal and external.

src/google/protobuf/compiler/cpp/cpp_helpers.cc

@@ -656,7 +656,7 @@ std::string DefaultValue(const Options& options, const FieldDescriptor* field) {
       } else if (value != value) {
         return "std::numeric_limits<double>::quiet_NaN()";
       } else {
-        return SimpleDtoa(value);
+        return StrCat(value);
       }
     }
     case FieldDescriptor::CPPTYPE_FLOAT: {
@@ -668,7 +668,7 @@ std::string DefaultValue(const Options& options, const FieldDescriptor* field) {
       } else if (value != value) {
         return "std::numeric_limits<float>::quiet_NaN()";
       } else {
-        std::string float_value = SimpleFtoa(value);
+        std::string float_value = StrCat(value);
         // If floating point value contains a period (.) or an exponent
         // (either E or e), then append suffix 'f' to make it a float
         // literal.

src/google/protobuf/compiler/csharp/csharp_enum.cc

@@ -79,12 +79,12 @@ void EnumGenerator::Generate(io::Printer* printer) {
           printer->Print("[pbr::OriginalName(\"$original_name$\", PreferredAlias = false)] $name$ = $number$,\n",
              "original_name", original_name,
              "name", name,
-             "number", SimpleItoa(number));
+             "number", StrCat(number));
       } else {
           printer->Print("[pbr::OriginalName(\"$original_name$\")] $name$ = $number$,\n",
              "original_name", original_name,
              "name", name,
-             "number", SimpleItoa(number));
+             "number", StrCat(number));
       }
   }
   printer->Outdent();

src/google/protobuf/compiler/csharp/csharp_field_base.cc

@@ -62,14 +62,14 @@ void FieldGeneratorBase::SetCommonFieldVariables(
   uint tag = internal::WireFormat::MakeTag(descriptor_);
   uint8 tag_array[5];
   io::CodedOutputStream::WriteTagToArray(tag, tag_array);
-  string tag_bytes = SimpleItoa(tag_array[0]);
+  string tag_bytes = StrCat(tag_array[0]);
   for (int i = 1; i < tag_size; i++) {
-    tag_bytes += ", " + SimpleItoa(tag_array[i]);
+    tag_bytes += ", " + StrCat(tag_array[i]);
   }
 
   (*variables)["access_level"] = "public";
-  (*variables)["tag"] = SimpleItoa(tag);
-  (*variables)["tag_size"] = SimpleItoa(tag_size);
+  (*variables)["tag"] = StrCat(tag);
+  (*variables)["tag_size"] = StrCat(tag_size);
   (*variables)["tag_bytes"] = tag_bytes;
 
   (*variables)["property_name"] = property_name();
@@ -91,8 +91,8 @@ void FieldGeneratorBase::SetCommonFieldVariables(
     (*variables)["has_not_property_check"] = "!" + (*variables)["has_property_check"];
     (*variables)["other_has_not_property_check"] = "!" + (*variables)["other_has_property_check"];
     if (presenceIndex_ != -1) {
-      string hasBitsNumber = SimpleItoa(presenceIndex_ / 32);
-      string hasBitsMask = SimpleItoa(1 << (presenceIndex_ % 32));
+      string hasBitsNumber = StrCat(presenceIndex_ / 32);
+      string hasBitsMask = StrCat(1 << (presenceIndex_ % 32));
       (*variables)["has_field_check"] = "(_hasBits" + hasBitsNumber + " & " + hasBitsMask + ") != 0";
       (*variables)["set_has_field"] = "_hasBits" + hasBitsNumber + " |= " + hasBitsMask;
       (*variables)["clear_has_field"] = "_hasBits" + hasBitsNumber + " &= ~" + hasBitsMask;
@@ -325,7 +325,7 @@ std::string FieldGeneratorBase::default_value(const FieldDescriptor* descriptor)
       } else if (std::isnan(value)) {
         return "double.NaN";
       }
-      return SimpleDtoa(value) + "D";
+      return StrCat(value) + "D";
     }
     case FieldDescriptor::TYPE_FLOAT: {
       float value = descriptor->default_value_float();
@@ -336,18 +336,18 @@ std::string FieldGeneratorBase::default_value(const FieldDescriptor* descriptor)
       } else if (std::isnan(value)) {
         return "float.NaN";
       }
-      return SimpleFtoa(value) + "F";
+      return StrCat(value) + "F";
     }
     case FieldDescriptor::TYPE_INT64:
-      return SimpleItoa(descriptor->default_value_int64()) + "L";
+      return StrCat(descriptor->default_value_int64()) + "L";
     case FieldDescriptor::TYPE_UINT64:
-      return SimpleItoa(descriptor->default_value_uint64()) + "UL";
+      return StrCat(descriptor->default_value_uint64()) + "UL";
     case FieldDescriptor::TYPE_INT32:
-      return SimpleItoa(descriptor->default_value_int32());
+      return StrCat(descriptor->default_value_int32());
     case FieldDescriptor::TYPE_FIXED64:
-      return SimpleItoa(descriptor->default_value_uint64()) + "UL";
+      return StrCat(descriptor->default_value_uint64()) + "UL";
     case FieldDescriptor::TYPE_FIXED32:
-      return SimpleItoa(descriptor->default_value_uint32());
+      return StrCat(descriptor->default_value_uint32());
     case FieldDescriptor::TYPE_BOOL:
       if (descriptor->default_value_bool()) {
         return "true";
@@ -359,15 +359,15 @@ std::string FieldGeneratorBase::default_value(const FieldDescriptor* descriptor)
     case FieldDescriptor::TYPE_BYTES:
       return GetBytesDefaultValueInternal(descriptor);
     case FieldDescriptor::TYPE_UINT32:
-      return SimpleItoa(descriptor->default_value_uint32());
+      return StrCat(descriptor->default_value_uint32());
     case FieldDescriptor::TYPE_SFIXED32:
-      return SimpleItoa(descriptor->default_value_int32());
+      return StrCat(descriptor->default_value_int32());
     case FieldDescriptor::TYPE_SFIXED64:
-      return SimpleItoa(descriptor->default_value_int64()) + "L";
+      return StrCat(descriptor->default_value_int64()) + "L";
     case FieldDescriptor::TYPE_SINT32:
-      return SimpleItoa(descriptor->default_value_int32());
+      return StrCat(descriptor->default_value_int32());
     case FieldDescriptor::TYPE_SINT64:
-      return SimpleItoa(descriptor->default_value_int64()) + "L";
+      return StrCat(descriptor->default_value_int64()) + "L";
     default:
       GOOGLE_LOG(FATAL)<< "Unknown field type.";
       return "";
@@ -375,7 +375,7 @@ std::string FieldGeneratorBase::default_value(const FieldDescriptor* descriptor)
 }
 
 std::string FieldGeneratorBase::number() {
-  return SimpleItoa(descriptor_->number());
+  return StrCat(descriptor_->number());
 }
 
 std::string FieldGeneratorBase::capitalized_type_name() {

src/google/protobuf/compiler/csharp/csharp_message.cc

@@ -137,7 +137,7 @@ void MessageGenerator::Generate(io::Printer* printer) {
   for (int i = 0; i < has_bit_field_count_; i++) {
     // don't use arrays since all arrays are heap allocated, saving allocations
     // use ints instead of bytes since bytes lack bitwise operators, saving casts
-    printer->Print("private int _hasBits$i$;\n", "i", SimpleItoa(i));
+    printer->Print("private int _hasBits$i$;\n", "i", StrCat(i));
   }
 
   WriteGeneratedCodeAttributes(printer);
@@ -149,10 +149,10 @@ void MessageGenerator::Generate(io::Printer* printer) {
   // Access the message descriptor via the relevant file descriptor or containing message descriptor.
   if (!descriptor_->containing_type()) {
     vars["descriptor_accessor"] = GetReflectionClassName(descriptor_->file())
-        + ".Descriptor.MessageTypes[" + SimpleItoa(descriptor_->index()) + "]";
+        + ".Descriptor.MessageTypes[" + StrCat(descriptor_->index()) + "]";
   } else {
     vars["descriptor_accessor"] = GetClassName(descriptor_->containing_type())
-        + ".Descriptor.NestedTypes[" + SimpleItoa(descriptor_->index()) + "]";
+        + ".Descriptor.NestedTypes[" + StrCat(descriptor_->index()) + "]";
   }
 
   WriteGeneratedCodeAttributes(printer);
@@ -198,7 +198,7 @@ void MessageGenerator::Generate(io::Printer* printer) {
       "public const int $field_constant_name$ = $index$;\n",
       "field_name", fieldDescriptor->name(),
       "field_constant_name", GetFieldConstantName(fieldDescriptor),
-      "index", SimpleItoa(fieldDescriptor->number()));
+      "index", StrCat(fieldDescriptor->number()));
     std::unique_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(fieldDescriptor));
     generator->GenerateMembers(printer);
@@ -221,7 +221,7 @@ void MessageGenerator::Generate(io::Printer* printer) {
       const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
       printer->Print("$field_property_name$ = $index$,\n",
                      "field_property_name", GetPropertyName(field),
-                     "index", SimpleItoa(field->number()));
+                     "index", StrCat(field->number()));
     }
     printer->Outdent();
     printer->Print("}\n");
@@ -306,7 +306,7 @@ void MessageGenerator::GenerateCloningCode(io::Printer* printer) {
     "public $class_name$($class_name$ other) : this() {\n");
   printer->Indent();
   for (int i = 0; i < has_bit_field_count_; i++) {
-    printer->Print("_hasBits$i$ = other._hasBits$i$;\n", "i", SimpleItoa(i));
+    printer->Print("_hasBits$i$ = other._hasBits$i$;\n", "i", StrCat(i));
   }
   // Clone non-oneof fields first
   for (int i = 0; i < descriptor_->field_count(); i++) {
@@ -545,7 +545,7 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
       printer->Print(
         "$end_tag$:\n"
         "  return;\n",
-        "end_tag", SimpleItoa(end_tag_));
+        "end_tag", StrCat(end_tag_));
     }
   }
   for (int i = 0; i < fields_by_number().size(); i++) {
@@ -562,13 +562,13 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
       printer->Print(
         "case $packed_tag$:\n",
         "packed_tag",
-        SimpleItoa(
+        StrCat(
             internal::WireFormatLite::MakeTag(
                 field->number(),
                 internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED)));
     }
 
-    printer->Print("case $tag$: {\n", "tag", SimpleItoa(tag));
+    printer->Print("case $tag$: {\n", "tag", StrCat(tag));
     printer->Indent();
     std::unique_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(field));

src/google/protobuf/compiler/csharp/csharp_message_field.cc

@@ -65,11 +65,11 @@ MessageFieldGenerator::MessageFieldGenerator(const FieldDescriptor* descriptor,
         internal::WireFormatLite::WIRETYPE_END_GROUP);
     uint8 tag_array[5];
     io::CodedOutputStream::WriteTagToArray(tag, tag_array);
-    string tag_bytes = SimpleItoa(tag_array[0]);
+    string tag_bytes = StrCat(tag_array[0]);
     for (int i = 1; i < tag_size; i++) {
-        tag_bytes += ", " + SimpleItoa(tag_array[i]);
+        tag_bytes += ", " + StrCat(tag_array[i]);
     }
-    variables_["end_tag"] = SimpleItoa(tag);
+    variables_["end_tag"] = StrCat(tag);
     variables_["end_tag_bytes"] = tag_bytes;
   }
 }

src/google/protobuf/compiler/csharp/csharp_primitive_field.cc

@@ -186,7 +186,7 @@ void PrimitiveFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
   } else {
     printer->Print(
       "size += $tag_size$ + $fixed_size$;\n",
-      "fixed_size", SimpleItoa(fixedSize),
+      "fixed_size", StrCat(fixedSize),
       "tag_size", variables_["tag_size"]);
   }
   printer->Outdent();

src/google/protobuf/compiler/java/java_helpers.cc

@@ -544,7 +544,7 @@ std::string DefaultValue(const FieldDescriptor* field, bool immutable,
       } else if (value != value) {
         return "Double.NaN";
       } else {
-        return SimpleDtoa(value) + "D";
+        return StrCat(value) + "D";
       }
     }
     case FieldDescriptor::CPPTYPE_FLOAT: {
@@ -556,7 +556,7 @@ std::string DefaultValue(const FieldDescriptor* field, bool immutable,
       } else if (value != value) {
         return "Float.NaN";
       } else {
-        return SimpleFtoa(value) + "F";
+        return StrCat(value) + "F";
       }
     }
     case FieldDescriptor::CPPTYPE_BOOL:

src/google/protobuf/compiler/js/js_generator.cc

@@ -733,9 +733,9 @@ std::string EscapeBase64(const std::string& in) {
   return result;
 }
 
-// Post-process the result of SimpleFtoa/SimpleDtoa to *exactly* match the
-// original codegen's formatting (which is just .toString() on java.lang.Double
-// or java.lang.Float).
+// Post-process the result of StrCat to *exactly* match the original codegen's
+// formatting (which is just .toString() on java.lang.Double or
+// java.lang.Float).
 std::string PostProcessFloat(std::string result) {
   // If inf, -inf or nan, replace with +Infinity, -Infinity or NaN.
   if (result == "inf") {
@@ -787,12 +787,12 @@ std::string PostProcessFloat(std::string result) {
 }
 
 std::string FloatToString(float value) {
-  std::string result = SimpleFtoa(value);
+  std::string result = StrCat(value);
   return PostProcessFloat(result);
 }
 
 std::string DoubleToString(double value) {
-  std::string result = SimpleDtoa(value);
+  std::string result = StrCat(value);
   return PostProcessFloat(result);
 }
 

src/google/protobuf/compiler/objectivec/objectivec_helpers.cc

@@ -818,10 +818,10 @@ string DefaultValue(const FieldDescriptor* field) {
       return StrCat(field->default_value_uint64()) + "ULL";
     case FieldDescriptor::CPPTYPE_DOUBLE:
       return HandleExtremeFloatingPoint(
-          SimpleDtoa(field->default_value_double()), false);
+          StrCat(field->default_value_double()), false);
     case FieldDescriptor::CPPTYPE_FLOAT:
       return HandleExtremeFloatingPoint(
-          SimpleFtoa(field->default_value_float()), true);
+          StrCat(field->default_value_float()), true);
     case FieldDescriptor::CPPTYPE_BOOL:
       return field->default_value_bool() ? "YES" : "NO";
     case FieldDescriptor::CPPTYPE_STRING: {

src/google/protobuf/compiler/parser.cc

@@ -1267,7 +1267,7 @@ bool Parser::ParseDefaultAssignment(
       double value;
       DO(ConsumeNumber(&value, "Expected number."));
       // And stringify it again.
-      default_value->append(SimpleDtoa(value));
+      default_value->append(StrCat(value));
       break;
 
     case FieldDescriptorProto::TYPE_BOOL:

src/google/protobuf/compiler/php/php_generator.cc

@@ -879,7 +879,7 @@ void GenerateMessageToPool(const string& name_prefix, const Descriptor* message,
           "field", field->name(),
           "key", ToUpper(key->type_name()),
           "value", ToUpper(val->type_name()),
-          "number", SimpleItoa(field->number()),
+          "number", StrCat(field->number()),
           "other", EnumOrMessageSuffix(val, true));
     } else if (!field->containing_oneof()) {
       printer->Print(
@@ -888,7 +888,7 @@ void GenerateMessageToPool(const string& name_prefix, const Descriptor* message,
           "field", field->name(),
           "label", LabelForField(field),
           "type", ToUpper(field->type_name()),
-          "number", SimpleItoa(field->number()),
+          "number", StrCat(field->number()),
           "other", EnumOrMessageSuffix(field, true));
     }
   }
@@ -906,7 +906,7 @@ void GenerateMessageToPool(const string& name_prefix, const Descriptor* message,
           "\\Google\\Protobuf\\Internal\\GPBType::^type^, ^number^^other^)\n",
           "field", field->name(),
           "type", ToUpper(field->type_name()),
-          "number", SimpleItoa(field->number()),
+          "number", StrCat(field->number()),
           "other", EnumOrMessageSuffix(field, true));
     }
     printer->Print("->finish()\n");

src/google/protobuf/compiler/python/python_generator.cc

@@ -250,7 +250,7 @@ std::string StringifyDefaultValue(const FieldDescriptor& field) {
         // infinity * 0 = nan
         return "(1e10000 * 0)";
       } else {
-        return "float(" + SimpleDtoa(value) + ")";
+        return "float(" + StrCat(value) + ")";
       }
     }
     case FieldDescriptor::CPPTYPE_FLOAT: {
@@ -266,7 +266,7 @@ std::string StringifyDefaultValue(const FieldDescriptor& field) {
         // infinity - infinity = nan
         return "(1e10000 * 0)";
       } else {
-        return "float(" + SimpleFtoa(value) + ")";
+        return "float(" + StrCat(value) + ")";
       }
     }
     case FieldDescriptor::CPPTYPE_BOOL: