Revert https://codereview.chromium.org/1291903002 (protobuf roll).

third_party/protobuf/src/google/protobuf/compiler/java/java_field.cc

Index: third_party/protobuf/src/google/protobuf/compiler/java/java_field.cc
diff --git a/third_party/protobuf/src/google/protobuf/compiler/java/java_field.cc b/third_party/protobuf/src/google/protobuf/compiler/java/java_field.cc
index 3f0fa11fe35438d65b0d200d1e51a0c62b67bf9f..c7d433c8efa2fd620eaf1c57aa32ce503fc5d776 100644
--- a/third_party/protobuf/src/google/protobuf/compiler/java/java_field.cc
+++ b/third_party/protobuf/src/google/protobuf/compiler/java/java_field.cc
@@ -1,6 +1,6 @@
 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
+// http://code.google.com/p/protobuf/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
@@ -33,296 +33,102 @@
 //  Sanjay Ghemawat, Jeff Dean, and others.
 
 #include <google/protobuf/compiler/java/java_field.h>
-
-#include <memory>
-#ifndef _SHARED_PTR_H
-#include <google/protobuf/stubs/shared_ptr.h>
-#endif
-
-#include <google/protobuf/stubs/common.h>
-#include <google/protobuf/compiler/java/java_context.h>
-#include <google/protobuf/compiler/java/java_enum_field.h>
-#include <google/protobuf/compiler/java/java_enum_field_lite.h>
 #include <google/protobuf/compiler/java/java_helpers.h>
-#include <google/protobuf/compiler/java/java_lazy_message_field.h>
-#include <google/protobuf/compiler/java/java_lazy_message_field_lite.h>
-#include <google/protobuf/compiler/java/java_map_field.h>
-#include <google/protobuf/compiler/java/java_map_field_lite.h>
-#include <google/protobuf/compiler/java/java_message_field.h>
-#include <google/protobuf/compiler/java/java_message_field_lite.h>
 #include <google/protobuf/compiler/java/java_primitive_field.h>
-#include <google/protobuf/compiler/java/java_primitive_field_lite.h>
+#include <google/protobuf/compiler/java/java_enum_field.h>
+#include <google/protobuf/compiler/java/java_message_field.h>
 #include <google/protobuf/compiler/java/java_string_field.h>
-#include <google/protobuf/compiler/java/java_string_field_lite.h>
-#include <google/protobuf/io/printer.h>
-#include <google/protobuf/stubs/strutil.h>
-#include <google/protobuf/stubs/substitute.h>
-
+#include <google/protobuf/stubs/common.h>
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace java {
 
-namespace {
+FieldGenerator::~FieldGenerator() {}
 
-ImmutableFieldGenerator* MakeImmutableGenerator(
-    const FieldDescriptor* field, int messageBitIndex, int builderBitIndex,
-    Context* context) {
-  if (field->is_repeated()) {
-    switch (GetJavaType(field)) {
-      case JAVATYPE_MESSAGE:
-        if (IsMapEntry(field->message_type())) {
-          return new ImmutableMapFieldGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        } else {
-          if (IsLazy(field)) {
-            return new RepeatedImmutableLazyMessageFieldGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          } else {
-            return new RepeatedImmutableMessageFieldGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          }
-        }
-      case JAVATYPE_ENUM:
-        return new RepeatedImmutableEnumFieldGenerator(
-            field, messageBitIndex, builderBitIndex, context);
-      case JAVATYPE_STRING:
-        return new RepeatedImmutableStringFieldGenerator(
-            field, messageBitIndex, builderBitIndex, context);
-      default:
-        return new RepeatedImmutablePrimitiveFieldGenerator(
-            field, messageBitIndex, builderBitIndex, context);
-    }
-  } else {
-    if (field->containing_oneof()) {
-      switch (GetJavaType(field)) {
-        case JAVATYPE_MESSAGE:
-          if (IsLazy(field)) {
-            return new ImmutableLazyMessageOneofFieldGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          } else {
-            return new ImmutableMessageOneofFieldGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          }
-        case JAVATYPE_ENUM:
-          return new ImmutableEnumOneofFieldGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        case JAVATYPE_STRING:
-          return new ImmutableStringOneofFieldGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        default:
-          return new ImmutablePrimitiveOneofFieldGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-      }
-    } else {
-      switch (GetJavaType(field)) {
-        case JAVATYPE_MESSAGE:
-          if (IsLazy(field)) {
-            return new ImmutableLazyMessageFieldGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          } else {
-            return new ImmutableMessageFieldGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          }
-        case JAVATYPE_ENUM:
-          return new ImmutableEnumFieldGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        case JAVATYPE_STRING:
-          return new ImmutableStringFieldGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        default:
-          return new ImmutablePrimitiveFieldGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-      }
-    }
-  }
-}
-
-ImmutableFieldLiteGenerator* MakeImmutableLiteGenerator(
-    const FieldDescriptor* field, int messageBitIndex, int builderBitIndex,
-    Context* context) {
-  if (field->is_repeated()) {
-    switch (GetJavaType(field)) {
-      case JAVATYPE_MESSAGE:
-        if (IsMapEntry(field->message_type())) {
-          return new ImmutableMapFieldLiteGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        } else {
-          if (IsLazy(field)) {
-            return new RepeatedImmutableLazyMessageFieldLiteGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          } else {
-            return new RepeatedImmutableMessageFieldLiteGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          }
-        }
-      case JAVATYPE_ENUM:
-        return new RepeatedImmutableEnumFieldLiteGenerator(
-            field, messageBitIndex, builderBitIndex, context);
-      case JAVATYPE_STRING:
-        return new RepeatedImmutableStringFieldLiteGenerator(
-            field, messageBitIndex, builderBitIndex, context);
-      default:
-        return new RepeatedImmutablePrimitiveFieldLiteGenerator(
-            field, messageBitIndex, builderBitIndex, context);
-    }
-  } else {
-    if (field->containing_oneof()) {
-      switch (GetJavaType(field)) {
-        case JAVATYPE_MESSAGE:
-          if (IsLazy(field)) {
-            return new ImmutableLazyMessageOneofFieldLiteGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          } else {
-            return new ImmutableMessageOneofFieldLiteGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          }
-        case JAVATYPE_ENUM:
-          return new ImmutableEnumOneofFieldLiteGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        case JAVATYPE_STRING:
-          return new ImmutableStringOneofFieldLiteGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        default:
-          return new ImmutablePrimitiveOneofFieldLiteGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-      }
-    } else {
-      switch (GetJavaType(field)) {
-        case JAVATYPE_MESSAGE:
-          if (IsLazy(field)) {
-            return new ImmutableLazyMessageFieldLiteGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          } else {
-            return new ImmutableMessageFieldLiteGenerator(
-                field, messageBitIndex, builderBitIndex, context);
-          }
-        case JAVATYPE_ENUM:
-          return new ImmutableEnumFieldLiteGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        case JAVATYPE_STRING:
-          return new ImmutableStringFieldLiteGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-        default:
-          return new ImmutablePrimitiveFieldLiteGenerator(
-              field, messageBitIndex, builderBitIndex, context);
-      }
-    }
-  }
-}
-
-
-static inline void ReportUnexpectedPackedFieldsCall(io::Printer* printer) {
+void FieldGenerator::GenerateParsingCodeFromPacked(io::Printer* printer) const {
   // Reaching here indicates a bug. Cases are:
-  //   - This FieldGenerator should support packing,
-  //     but this method should be overridden.
-  //   - This FieldGenerator doesn't support packing, and this method
-  //     should never have been called.
+  //   - This FieldGenerator should support packing, but this method should be
+  //     overridden.
+  //   - This FieldGenerator doesn't support packing, and this method should
+  //     never have been called.
   GOOGLE_LOG(FATAL) << "GenerateParsingCodeFromPacked() "
              << "called on field generator that does not support packing.";
 }
 
-}  // namespace
-
-ImmutableFieldGenerator::~ImmutableFieldGenerator() {}
-
-void ImmutableFieldGenerator::
-GenerateParsingCodeFromPacked(io::Printer* printer) const {
-  ReportUnexpectedPackedFieldsCall(printer);
-}
-
-ImmutableFieldLiteGenerator::~ImmutableFieldLiteGenerator() {}
-
-void ImmutableFieldLiteGenerator::
-GenerateParsingCodeFromPacked(io::Printer* printer) const {
-  ReportUnexpectedPackedFieldsCall(printer);
-}
-
-// ===================================================================
-
-template <>
-FieldGeneratorMap<ImmutableFieldGenerator>::FieldGeneratorMap(
-    const Descriptor* descriptor, Context* context)
-    : descriptor_(descriptor),
-      field_generators_(new google::protobuf::scoped_ptr<
-          ImmutableFieldGenerator>[descriptor->field_count()]) {
+FieldGeneratorMap::FieldGeneratorMap(const Descriptor* descriptor)
+  : descriptor_(descriptor),
+    field_generators_(
+      new scoped_ptr<FieldGenerator>[descriptor->field_count()]),
+    extension_generators_(
+      new scoped_ptr<FieldGenerator>[descriptor->extension_count()]) {
 
   // Construct all the FieldGenerators and assign them bit indices for their
   // bit fields.
   int messageBitIndex = 0;
   int builderBitIndex = 0;
   for (int i = 0; i < descriptor->field_count(); i++) {
-    ImmutableFieldGenerator* generator = MakeImmutableGenerator(
-        descriptor->field(i), messageBitIndex, builderBitIndex, context);
+    FieldGenerator* generator = MakeGenerator(descriptor->field(i),
+        messageBitIndex, builderBitIndex);
     field_generators_[i].reset(generator);
     messageBitIndex += generator->GetNumBitsForMessage();
     builderBitIndex += generator->GetNumBitsForBuilder();
   }
-}
-
-template<>
-FieldGeneratorMap<ImmutableFieldGenerator>::~FieldGeneratorMap() {}
-
-template <>
-FieldGeneratorMap<ImmutableFieldLiteGenerator>::FieldGeneratorMap(
-    const Descriptor* descriptor, Context* context)
-    : descriptor_(descriptor),
-      field_generators_(new google::protobuf::scoped_ptr<
-          ImmutableFieldLiteGenerator>[descriptor->field_count()]) {
-  // Construct all the FieldGenerators and assign them bit indices for their
-  // bit fields.
-  int messageBitIndex = 0;
-  int builderBitIndex = 0;
-  for (int i = 0; i < descriptor->field_count(); i++) {
-    ImmutableFieldLiteGenerator* generator = MakeImmutableLiteGenerator(
-        descriptor->field(i), messageBitIndex, builderBitIndex, context);
-    field_generators_[i].reset(generator);
+  for (int i = 0; i < descriptor->extension_count(); i++) {
+    FieldGenerator* generator = MakeGenerator(descriptor->extension(i),
+        messageBitIndex, builderBitIndex);
+    extension_generators_[i].reset(generator);
     messageBitIndex += generator->GetNumBitsForMessage();
     builderBitIndex += generator->GetNumBitsForBuilder();
   }
 }
 
-template<>
-FieldGeneratorMap<ImmutableFieldLiteGenerator>::~FieldGeneratorMap() {}
-
-
-void SetCommonFieldVariables(const FieldDescriptor* descriptor,
-                             const FieldGeneratorInfo* info,
-                             map<string, string>* variables) {
-  (*variables)["field_name"] = descriptor->name();
-  (*variables)["name"] = info->name;
-  (*variables)["capitalized_name"] = info->capitalized_name;
-  (*variables)["disambiguated_reason"] = info->disambiguated_reason;
-  (*variables)["constant_name"] = FieldConstantName(descriptor);
-  (*variables)["number"] = SimpleItoa(descriptor->number());
+FieldGenerator* FieldGeneratorMap::MakeGenerator(
+    const FieldDescriptor* field, int messageBitIndex, int builderBitIndex) {
+  if (field->is_repeated()) {
+    switch (GetJavaType(field)) {
+      case JAVATYPE_MESSAGE:
+        return new RepeatedMessageFieldGenerator(
+            field, messageBitIndex, builderBitIndex);
+      case JAVATYPE_ENUM:
+        return new RepeatedEnumFieldGenerator(
+            field, messageBitIndex, builderBitIndex);
+      case JAVATYPE_STRING:
+        return new RepeatedStringFieldGenerator(
+            field, messageBitIndex, builderBitIndex);
+      default:
+        return new RepeatedPrimitiveFieldGenerator(
+            field, messageBitIndex, builderBitIndex);
+    }
+  } else {
+    switch (GetJavaType(field)) {
+      case JAVATYPE_MESSAGE:
+        return new MessageFieldGenerator(
+            field, messageBitIndex, builderBitIndex);
+      case JAVATYPE_ENUM:
+        return new EnumFieldGenerator(
+            field, messageBitIndex, builderBitIndex);
+      case JAVATYPE_STRING:
+        return new StringFieldGenerator(
+            field, messageBitIndex, builderBitIndex);
+      default:
+        return new PrimitiveFieldGenerator(
+            field, messageBitIndex, builderBitIndex);
+    }
+  }
 }
 
-void SetCommonOneofVariables(const FieldDescriptor* descriptor,
-                             const OneofGeneratorInfo* info,
-                             map<string, string>* variables) {
-  (*variables)["oneof_name"] = info->name;
-  (*variables)["oneof_capitalized_name"] = info->capitalized_name;
-  (*variables)["oneof_index"] =
-      SimpleItoa(descriptor->containing_oneof()->index());
-  (*variables)["set_oneof_case_message"] = info->name +
-      "Case_ = " + SimpleItoa(descriptor->number());
-  (*variables)["clear_oneof_case_message"] = info->name +
-      "Case_ = 0";
-  (*variables)["has_oneof_case_message"] = info->name +
-      "Case_ == " + SimpleItoa(descriptor->number());
+FieldGeneratorMap::~FieldGeneratorMap() {}
+
+const FieldGenerator& FieldGeneratorMap::get(
+    const FieldDescriptor* field) const {
+  GOOGLE_CHECK_EQ(field->containing_type(), descriptor_);
+  return *field_generators_[field->index()];
 }
 
-void PrintExtraFieldInfo(const map<string, string>& variables,
-                         io::Printer* printer) {
-  const map<string, string>::const_iterator it =
-      variables.find("disambiguated_reason");
-  if (it != variables.end() && !it->second.empty()) {
-    printer->Print(
-        variables,
-        "// An alternative name is used for field \"$field_name$\" because:\n"
-        "//     $disambiguated_reason$\n");
-  }
+const FieldGenerator& FieldGeneratorMap::get_extension(int index) const {
+  return *extension_generators_[index];
 }
 
 }  // namespace java