Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_file.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 42 matching lines @@
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace cpp {
 
 // ===================================================================
 
 FileGenerator::FileGenerator(const FileDescriptor* file, const Options& options)
     : file_(file),
       options_(options),
-      message_generators_owner_(
-          new google::protobuf::scoped_ptr<MessageGenerator>[ file->message_type_count() ]),
-      enum_generators_owner_(
-          new google::protobuf::scoped_ptr<EnumGenerator>[ file->enum_type_count() ]),
-      service_generators_owner_(
-          new google::protobuf::scoped_ptr<ServiceGenerator>[ file->service_count() ]),
-      extension_generators_owner_(
-          new google::protobuf::scoped_ptr<ExtensionGenerator>[ file->extension_count() ]) {
+      message_generators_(
+          new google::protobuf::scoped_ptr<MessageGenerator>[file->message_type_count()]),
+      enum_generators_(
+          new google::protobuf::scoped_ptr<EnumGenerator>[file->enum_type_count()]),
+      service_generators_(
+          new google::protobuf::scoped_ptr<ServiceGenerator>[file->service_count()]),
+      extension_generators_(
+          new google::protobuf::scoped_ptr<ExtensionGenerator>[file->extension_count()]) {
 
   for (int i = 0; i < file->message_type_count(); i++) {
-    message_generators_owner_[i].reset(
-        new MessageGenerator(file->message_type(i), options));
-    message_generators_owner_[i]->Flatten(&message_generators_);
-  }
-
-  for (int i = 0; i < message_generators_.size(); i++) {
-    message_generators_[i]->AddGenerators(&enum_generators_,
-                                          &extension_generators_);
+    message_generators_[i].reset(
+      new MessageGenerator(file->message_type(i), options));
   }
 
   for (int i = 0; i < file->enum_type_count(); i++) {
-    enum_generators_owner_[i].reset(
-        new EnumGenerator(file->enum_type(i), options));
-    enum_generators_.push_back(enum_generators_owner_[i].get());
+    enum_generators_[i].reset(
+      new EnumGenerator(file->enum_type(i), options));
   }
 
   for (int i = 0; i < file->service_count(); i++) {
-    service_generators_owner_[i].reset(
-        new ServiceGenerator(file->service(i), options));
-    service_generators_.push_back(service_generators_owner_[i].get());
+    service_generators_[i].reset(
+      new ServiceGenerator(file->service(i), options));
   }
 
   for (int i = 0; i < file->extension_count(); i++) {
-    extension_generators_owner_[i].reset(
-        new ExtensionGenerator(file->extension(i), options));
-    extension_generators_.push_back(extension_generators_owner_[i].get());
+    extension_generators_[i].reset(
+      new ExtensionGenerator(file->extension(i), options));
   }
 
-  package_parts_ = Split(file_->package(), ".", true);
+  SplitStringUsing(file_->package(), ".", &package_parts_);
 }
 
 FileGenerator::~FileGenerator() {}
 
-void FileGenerator::GenerateHeader(io::Printer* printer) {
+void FileGenerator::GenerateProtoHeader(io::Printer* printer,
+                                        const string& info_path) {
+  if (!options_.proto_h) {
+    return;
+  }
+
+  string filename_identifier = FilenameIdentifier(file_->name());
+  GenerateTopHeaderGuard(printer, filename_identifier);
+
+
+  GenerateLibraryIncludes(printer);
+
+  for (int i = 0; i < file_->public_dependency_count(); i++) {
+    const FileDescriptor* dep = file_->public_dependency(i);
+    const char* extension = ".proto.h";
+    string dependency = StripProto(dep->name()) + extension;
+    printer->Print(
+      "#include \"$dependency$\"  // IWYU pragma: export\n",
+      "dependency", dependency);
+  }
+
+  GenerateMetadataPragma(printer, info_path);
+
   printer->Print(
     "// @@protoc_insertion_point(includes)\n");
 
 
   GenerateForwardDeclarations(printer);
 
   // Open namespace.
   GenerateNamespaceOpeners(printer);
 
   GenerateGlobalStateFunctionDeclarations(printer);
@@ skipping 29 matching lines @@
   // Close up namespace.
   GenerateNamespaceClosers(printer);
 
   // We need to specialize some templates in the ::google::protobuf namespace:
   GenerateProto2NamespaceEnumSpecializations(printer);
 
   printer->Print(
     "\n"
     "// @@protoc_insertion_point(global_scope)\n"
     "\n");
-}
-
-void FileGenerator::GenerateProtoHeader(io::Printer* printer,
-                                        const string& info_path) {
-  if (!options_.proto_h) {
-    return;
-  }
-
-  string filename_identifier = FilenameIdentifier(file_->name());
-  GenerateTopHeaderGuard(printer, filename_identifier);
-
-
-  GenerateLibraryIncludes(printer);
-
-  for (int i = 0; i < file_->public_dependency_count(); i++) {
-    const FileDescriptor* dep = file_->public_dependency(i);
-    const char* extension = ".proto.h";
-    string dependency = StripProto(dep->name()) + extension;
-    printer->Print(
-      "#include \"$dependency$\"  // IWYU pragma: export\n",
-      "dependency", dependency);
-  }
-
-  GenerateMetadataPragma(printer, info_path);
-
-  GenerateHeader(printer);
 
   GenerateBottomHeaderGuard(printer, filename_identifier);
 }
 
 void FileGenerator::GeneratePBHeader(io::Printer* printer,
                                      const string& info_path) {
   string filename_identifier =
       FilenameIdentifier(file_->name() + (options_.proto_h ? ".pb.h" : ""));
   GenerateTopHeaderGuard(printer, filename_identifier);
 
   if (options_.proto_h) {
     printer->Print("#include \"$basename$.proto.h\"  // IWYU pragma: export\n",
                    "basename", StripProto(file_->name()));
   } else {
     GenerateLibraryIncludes(printer);
   }
   GenerateDependencyIncludes(printer);
   GenerateMetadataPragma(printer, info_path);
 
+  printer->Print(
+    "// @@protoc_insertion_point(includes)\n");
+
+
+
+  // Open namespace.
+  GenerateNamespaceOpeners(printer);
+
   if (!options_.proto_h) {
-    GenerateHeader(printer);
-  } else {
-    // This is unfortunately necessary for some plugins. I don't see why we
-    // need two of the same insertion points.
-    // TODO(gerbens) remove this.
-    printer->Print(
-      "// @@protoc_insertion_point(includes)\n");
+    GenerateGlobalStateFunctionDeclarations(printer);
+    GenerateMessageForwardDeclarations(printer);
 
-    // Open namespace.
-    GenerateNamespaceOpeners(printer);
-    printer->Print(
-      "\n"
-      "// @@protoc_insertion_point(namespace_scope)\n");
-    // Close up namespace.
-    GenerateNamespaceClosers(printer);
+    printer->Print("\n");
 
-    printer->Print(
-      "\n"
-      "// @@protoc_insertion_point(global_scope)\n"
-      "\n");
+    GenerateEnumDefinitions(printer);
+
+    printer->Print(kThickSeparator);
+    printer->Print("\n");
+
+    GenerateMessageDefinitions(printer);
+
+    printer->Print("\n");
+    printer->Print(kThickSeparator);
+    printer->Print("\n");
+
+    GenerateServiceDefinitions(printer);
+
+    GenerateExtensionIdentifiers(printer);
+
+    printer->Print("\n");
+    printer->Print(kThickSeparator);
+    printer->Print("\n");
+
+    GenerateInlineFunctionDefinitions(printer);
   }
 
+  printer->Print(
+    "\n"
+    "// @@protoc_insertion_point(namespace_scope)\n");
+
+  // Close up namespace.
+  GenerateNamespaceClosers(printer);
+
+  if (!options_.proto_h) {
+    // We need to specialize some templates in the ::google::protobuf namespace:
+    GenerateProto2NamespaceEnumSpecializations(printer);
+  }
+
+  printer->Print(
+    "\n"
+    "// @@protoc_insertion_point(global_scope)\n"
+    "\n");
+
   GenerateBottomHeaderGuard(printer, filename_identifier);
 }
 
 void FileGenerator::GenerateSource(io::Printer* printer) {
   const bool use_system_include = IsWellKnownMessage(file_);
   string header =
       StripProto(file_->name()) + (options_.proto_h ? ".proto.h" : ".pb.h");
   printer->Print(
     "// Generated by the protocol buffer compiler.  DO NOT EDIT!\n"
     "// source: $filename$\n"
     "\n"
     // The generated code calls accessors that might be deprecated. We don't
     // want the compiler to warn in generated code.
     "#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION\n"
     "#include $left$$header$$right$\n"
     "\n"
     "#include <algorithm>\n"    // for swap()
     "\n"
     "#include <google/protobuf/stubs/common.h>\n"
     "#include <google/protobuf/stubs/port.h>\n"
     "#include <google/protobuf/stubs/once.h>\n"
     "#include <google/protobuf/io/coded_stream.h>\n"
     "#include <google/protobuf/wire_format_lite_inl.h>\n",
     "filename", file_->name(),
     "header", header,
     "left", use_system_include ? "<" : "\"",
     "right", use_system_include ? ">" : "\"");
 
   // Unknown fields implementation in lite mode uses StringOutputStream
-  if (!UseUnknownFieldSet(file_, options_) && !message_generators_.empty()) {
+  if (!UseUnknownFieldSet(file_, options_) && file_->message_type_count() > 0) {
     printer->Print(
       "#include <google/protobuf/io/zero_copy_stream_impl_lite.h>\n");
   }
 
   if (HasDescriptorMethods(file_, options_)) {
     printer->Print(
       "#include <google/protobuf/descriptor.h>\n"
       "#include <google/protobuf/generated_message_reflection.h>\n"
       "#include <google/protobuf/reflection_ops.h>\n"
       "#include <google/protobuf/wire_format.h>\n");
   }
 
   if (options_.proto_h) {
     // Use the smaller .proto.h files.
     for (int i = 0; i < file_->dependency_count(); i++) {
       const FileDescriptor* dep = file_->dependency(i);
       const char* extension = ".proto.h";
       string dependency = StripProto(dep->name()) + extension;
       printer->Print(
           "#include \"$dependency$\"\n",
           "dependency", dependency);
     }
   }
 
   printer->Print(
     "// @@protoc_insertion_point(includes)\n");
 
   GenerateNamespaceOpeners(printer);
 
-  for (int i = 0; i < message_generators_.size(); i++) {
-    if (IsMapEntryMessage(message_generators_[i]->descriptor_)) continue;
-    printer->Print(
-        "class $classname$DefaultTypeInternal : "
-        "public ::google::protobuf::internal::ExplicitlyConstructed<$classname$> {};\n"
-        "$classname$DefaultTypeInternal _$classname$_default_instance_;\n",
-        "classname", message_generators_[i]->classname_);
-  }
-
-  for (int i = 0; i < message_generators_.size(); i++) {
-    message_generators_[i]->index_in_metadata_ = i;
-  }
-  for (int i = 0; i < enum_generators_.size(); i++) {
-    enum_generators_[i]->index_in_metadata_ = i;
-  }
-  if (HasGenericServices(file_, options_)) {
-    for (int i = 0; i < service_generators_.size(); i++) {
-      service_generators_[i]->index_in_metadata_ = i;
-    }
-  }
-
   if (HasDescriptorMethods(file_, options_)) {
     printer->Print(
       "\n"
       "namespace {\n"
       "\n");
-
-    if (!message_generators_.empty()) {
-      printer->Print("::google::protobuf::Metadata file_level_metadata[$size$];\n",
-                     "size", SimpleItoa(message_generators_.size()));
+    for (int i = 0; i < file_->message_type_count(); i++) {
+      message_generators_[i]->GenerateDescriptorDeclarations(printer);
     }
-    if (!enum_generators_.empty()) {
+    for (int i = 0; i < file_->enum_type_count(); i++) {
       printer->Print(
-          "const ::google::protobuf::EnumDescriptor* "
-          "file_level_enum_descriptors[$size$];\n",
-          "size", SimpleItoa(enum_generators_.size()));
-    }
-    if (HasGenericServices(file_, options_) && file_->service_count() > 0) {
-      printer->Print(
-          "const ::google::protobuf::ServiceDescriptor* "
-          "file_level_service_descriptors[$size$];\n",
-          "size", SimpleItoa(file_->service_count()));
+        "const ::google::protobuf::EnumDescriptor* $name$_descriptor_ = NULL;\n",
+        "name", ClassName(file_->enum_type(i), false));
     }
 
-    for (int i = 0; i < message_generators_.size(); i++) {
-      message_generators_[i]->GenerateDescriptorDeclarations(printer);
+    if (HasGenericServices(file_, options_)) {
+      for (int i = 0; i < file_->service_count(); i++) {
+        printer->Print(
+          "const ::google::protobuf::ServiceDescriptor* $name$_descriptor_ = NULL;\n",
+          "name", file_->service(i)->name());
+      }
     }
 
     printer->Print(
       "\n"
       "}  // namespace\n"
       "\n");
   }
 
   // Define our externally-visible BuildDescriptors() function.  (For the lite
   // library, all this does is initialize default instances.)
   GenerateBuildDescriptors(printer);
 
   // Generate enums.
-  for (int i = 0; i < enum_generators_.size(); i++) {
+  for (int i = 0; i < file_->enum_type_count(); i++) {
     enum_generators_[i]->GenerateMethods(printer);
   }
 
   // Generate classes.
-  for (int i = 0; i < message_generators_.size(); i++) {
+  for (int i = 0; i < file_->message_type_count(); i++) {
+    if (i == 0 && HasGeneratedMethods(file_, options_)) {
+      printer->Print(
+          "\n"
+          "namespace {\n"
+          "\n"
+          "static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD;\n"
+          "GOOGLE_ATTRIBUTE_NOINLINE static void MergeFromFail(int line) {\n"
+          "  GOOGLE_CHECK(false) << __FILE__ << \":\" << line;\n"
+          "}\n"
+          "\n"
+          "}  // namespace\n"
+          "\n");
+    }
     printer->Print("\n");
     printer->Print(kThickSeparator);
     printer->Print("\n");
     message_generators_[i]->GenerateClassMethods(printer);
 
     printer->Print("#if PROTOBUF_INLINE_NOT_IN_HEADERS\n");
     // Generate class inline methods.
     message_generators_[i]->GenerateInlineMethods(printer,
                                                   /* is_inline = */ false);
     printer->Print("#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS\n");
   }
 
   if (HasGenericServices(file_, options_)) {
     // Generate services.
-    for (int i = 0; i < service_generators_.size(); i++) {
+    for (int i = 0; i < file_->service_count(); i++) {
       if (i == 0) printer->Print("\n");
       printer->Print(kThickSeparator);
       printer->Print("\n");
       service_generators_[i]->GenerateImplementation(printer);
     }
   }
 
   // Define extensions.
-  for (int i = 0; i < extension_generators_.size(); i++) {
+  for (int i = 0; i < file_->extension_count(); i++) {
     extension_generators_[i]->GenerateDefinition(printer);
   }
 
   printer->Print(
     "\n"
     "// @@protoc_insertion_point(namespace_scope)\n");
 
   GenerateNamespaceClosers(printer);
 
   printer->Print(
     "\n"
     "// @@protoc_insertion_point(global_scope)\n");
 }
 
 class FileGenerator::ForwardDeclarations {
  public:
   ~ForwardDeclarations() {
-    for (std::map<string, ForwardDeclarations*>::iterator
-             it = namespaces_.begin(),
-             end = namespaces_.end();
+    for (map<string, ForwardDeclarations *>::iterator it = namespaces_.begin(),
+                                                      end = namespaces_.end();
          it != end; ++it) {
       delete it->second;
     }
     namespaces_.clear();
   }
 
   ForwardDeclarations* AddOrGetNamespace(const string& ns_name) {
     ForwardDeclarations*& ns = namespaces_[ns_name];
     if (ns == NULL) {
       ns = new ForwardDeclarations;
     }
     return ns;
   }
 
-  std::map<string, const Descriptor*>& classes() { return classes_; }
-  std::map<string, const EnumDescriptor*>& enums() { return enums_; }
+  map<string, const Descriptor*>& classes() { return classes_; }
+  map<string, const EnumDescriptor*>& enums() { return enums_; }
 
-  void Print(io::Printer* printer, const Options& options) const {
-    for (std::map<string, const EnumDescriptor *>::const_iterator
+  void Print(io::Printer* printer) const {
+    for (map<string, const EnumDescriptor *>::const_iterator
              it = enums_.begin(),
              end = enums_.end();
          it != end; ++it) {
       printer->Print("enum $enumname$ : int;\n", "enumname", it->first);
       printer->Annotate("enumname", it->second);
       printer->Print("bool $enumname$_IsValid(int value);\n", "enumname",
                      it->first);
     }
-    for (std::map<string, const Descriptor*>::const_iterator
-             it = classes_.begin(),
-             end = classes_.end();
+    for (map<string, const Descriptor *>::const_iterator it = classes_.begin(),
+                                                         end = classes_.end();
          it != end; ++it) {
       printer->Print("class $classname$;\n", "classname", it->first);
       printer->Annotate("classname", it->second);
-
-      printer->Print(
-          "class $classname$DefaultTypeInternal;\n"
-          "$dllexport_decl$"
-          "extern $classname$DefaultTypeInternal "
-          "_$classname$_default_instance_;\n",  // NOLINT
-          "dllexport_decl",
-          options.dllexport_decl.empty() ? "" : options.dllexport_decl + " ",
-          "classname",
-          it->first);
     }
-    for (std::map<string, ForwardDeclarations *>::const_iterator
+    for (map<string, ForwardDeclarations *>::const_iterator
              it = namespaces_.begin(),
              end = namespaces_.end();
          it != end; ++it) {
       printer->Print("namespace $nsname$ {\n",
                      "nsname", it->first);
-      it->second->Print(printer, options);
+      it->second->Print(printer);
       printer->Print("}  // namespace $nsname$\n",
                      "nsname", it->first);
     }
   }
 
 
  private:
-  std::map<string, ForwardDeclarations*> namespaces_;
-  std::map<string, const Descriptor*> classes_;
-  std::map<string, const EnumDescriptor*> enums_;
+  map<string, ForwardDeclarations*> namespaces_;
+  map<string, const Descriptor*> classes_;
+  map<string, const EnumDescriptor*> enums_;
 };
 
 void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
   // AddDescriptors() is a file-level procedure which adds the encoded
   // FileDescriptorProto for this .proto file to the global DescriptorPool for
   // generated files (DescriptorPool::generated_pool()). It either runs at
   // static initialization time (by default) or when default_instance() is
   // called for the first time (in LITE_RUNTIME mode with
   // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER flag enabled). This procedure also
   // constructs default instances and registers extensions.
   //
   // Its sibling, AssignDescriptors(), actually pulls the compiled
   // FileDescriptor from the DescriptorPool and uses it to populate all of
   // the global variables which store pointers to the descriptor objects.
   // It also constructs the reflection objects.  It is called the first time
   // anyone calls descriptor() or GetReflection() on one of the types defined
   // in the file.
 
   // In optimize_for = LITE_RUNTIME mode, we don't generate AssignDescriptors()
   // and we only use AddDescriptors() to allocate default instances.
+  if (HasDescriptorMethods(file_, options_)) {
+    printer->Print(
+      "\n"
+      "void $assigndescriptorsname$() {\n",
+      "assigndescriptorsname", GlobalAssignDescriptorsName(file_->name()));
+    printer->Indent();
 
-  if (HasDescriptorMethods(file_, options_)) {
-    if (!message_generators_.empty()) {
-      printer->Print(
-          "\n"
-          "const ::google::protobuf::uint32* $offsetfunname$() GOOGLE_ATTRIBUTE_COLD;\n"
-          "const ::google::protobuf::uint32* $offsetfunname$() {\n",
-          "offsetfunname", GlobalOffsetTableName(file_->name()));
-      printer->Indent();
+    // Make sure the file has found its way into the pool.  If a descriptor
+    // is requested *during* static init then AddDescriptors() may not have
+    // been called yet, so we call it manually.  Note that it's fine if
+    // AddDescriptors() is called multiple times.
+    printer->Print(
+      "$adddescriptorsname$();\n",
+      "adddescriptorsname", GlobalAddDescriptorsName(file_->name()));
 
-      printer->Print("static const ::google::protobuf::uint32 offsets[] = {\n");
-      printer->Indent();
-      std::vector<std::pair<size_t, size_t> > pairs;
-      for (int i = 0; i < message_generators_.size(); i++) {
-        pairs.push_back(message_generators_[i]->GenerateOffsets(printer));
+    // Get the file's descriptor from the pool.
+    printer->Print(
+      "const ::google::protobuf::FileDescriptor* file =\n"
+      "  ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(\n"
+      "    \"$filename$\");\n"
+      // Note that this GOOGLE_CHECK is necessary to prevent a warning about "file"
+      // being unused when compiling an empty .proto file.
+      "GOOGLE_CHECK(file != NULL);\n",
+      "filename", file_->name());
+
+    // Go through all the stuff defined in this file and generated code to
+    // assign the global descriptor pointers based on the file descriptor.
+    for (int i = 0; i < file_->message_type_count(); i++) {
+      message_generators_[i]->GenerateDescriptorInitializer(printer, i);
+    }
+    for (int i = 0; i < file_->enum_type_count(); i++) {
+      enum_generators_[i]->GenerateDescriptorInitializer(printer, i);
+    }
+    if (HasGenericServices(file_, options_)) {
+      for (int i = 0; i < file_->service_count(); i++) {
+        service_generators_[i]->GenerateDescriptorInitializer(printer, i);
       }
-      printer->Outdent();
-      printer->Outdent();
-      printer->Print(
-          "  };\n"
-          "  return offsets;\n"
-          "}\n"
-          "\n");
+    }
 
-      printer->Print(
-          "static const ::google::protobuf::internal::MigrationSchema schemas[] = {\n");
-      printer->Indent();
-      {
-        int offset = 0;
-        for (int i = 0; i < message_generators_.size(); i++) {
-          message_generators_[i]->GenerateSchema(printer, offset,
-                                                 pairs[i].second);
-          offset += pairs[i].first;
-        }
-      }
-      printer->Outdent();
-      printer->Print(
-          "};\n"
-          "\n"
-          "static const ::google::protobuf::internal::DefaultInstanceData "
-          "file_default_instances[] = {\n");
-      printer->Indent();
-      for (int i = 0; i < message_generators_.size(); i++) {
-        const Descriptor* descriptor = message_generators_[i]->descriptor_;
-        if (IsMapEntryMessage(descriptor)) continue;
-
-        string oneof_default = "NULL";
-        if (message_generators_[i]->descriptor_->oneof_decl_count()) {
-          oneof_default =
-              "&" + ClassName(descriptor, false) + "_default_oneof_instance_";
-        }
-        printer->Print(
-            "{reinterpret_cast<const "
-            "::google::protobuf::Message*>(&_$classname$_default_instance_), "
-            "$oneof_default$},\n",
-            "classname", ClassName(descriptor, false), "oneof_default",
-            oneof_default);
-      }
-      printer->Outdent();
-      printer->Print(
-          "};\n"
-          "\n");
-    } else {
-      // we still need these symbols to exist
-      printer->Print(
-          "inline ::google::protobuf::uint32* $offsetfunname$() { return NULL; }\n"
-          "static const ::google::protobuf::internal::MigrationSchema* schemas = NULL;\n"
-          "static const ::google::protobuf::internal::DefaultInstanceData* "
-          "file_default_instances = NULL;\n",
-          "offsetfunname",
-          GlobalOffsetTableName(file_->name()));
-    }
+    printer->Outdent();
+    printer->Print(
+      "}\n"
+      "\n");
 
     // ---------------------------------------------------------------
 
     // protobuf_AssignDescriptorsOnce():  The first time it is called, calls
     // AssignDescriptors().  All later times, waits for the first call to
     // complete and then returns.
-    string message_factory = "NULL";
     printer->Print(
-        "namespace {\n"
-        "\n"
-        "void protobuf_AssignDescriptors() {\n"
-        // Make sure the file has found its way into the pool.  If a descriptor
-        // is requested *during* static init then AddDescriptors() may not have
-        // been called yet, so we call it manually.  Note that it's fine if
-        // AddDescriptors() is called multiple times.
-        "  $adddescriptorsname$();\n"
-        "  ::google::protobuf::MessageFactory* factory = $factory$;\n"
-        "  AssignDescriptors(\n"
-        "      \"$filename$\", schemas, file_default_instances, "
-        "$offsetfunname$(), factory,\n"
-        "      $metadata$, $enum_descriptors$, $service_descriptors$);\n"
-        "}\n"
-        "\n"
-        "void protobuf_AssignDescriptorsOnce() {\n"
-        "  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);\n"
-        "  ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);\n"
-        "}\n"
-        "\n",
-        "adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
-        "offsetfunname", GlobalOffsetTableName(file_->name()), "filename",
-        file_->name(), "metadata",
-        !message_generators_.empty() ? "file_level_metadata" : "NULL",
-        "enum_descriptors",
-        !enum_generators_.empty() ? "file_level_enum_descriptors" : "NULL",
-        "service_descriptors",
-        HasGenericServices(file_, options_) && file_->service_count() > 0
-            ? "file_level_service_descriptors"
-            : "NULL",
-        "factory", message_factory);
+      "namespace {\n"
+      "\n"
+      "GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);\n"
+      "inline void protobuf_AssignDescriptorsOnce() {\n"
+      "  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,\n"
+      "                 &$assigndescriptorsname$);\n"
+      "}\n"
+      "\n",
+      "assigndescriptorsname", GlobalAssignDescriptorsName(file_->name()));
 
-    // Only here because of useless string reference that we don't want in
-    // protobuf_AssignDescriptorsOnce, because that is called from all the
-    // GetMetadata member methods.
+    // protobuf_RegisterTypes():  Calls
+    // MessageFactory::InternalRegisterGeneratedType() for each message type.
     printer->Print(
-        "void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD;\n"
-        "void protobuf_RegisterTypes(const ::std::string&) {\n"
-        "  protobuf_AssignDescriptorsOnce();\n");
+      "void protobuf_RegisterTypes(const ::std::string&) {\n"
+      "  protobuf_AssignDescriptorsOnce();\n");
     printer->Indent();
 
-    // All normal messages can be done generically
-    if (!message_generators_.empty()) {
-      printer->Print(
-        "::google::protobuf::internal::RegisterAllTypes(file_level_metadata, $size$);\n",
-        "size", SimpleItoa(message_generators_.size()));
-    }
-
-    // Map types are treated special
-    // TODO(gerbens) find a way to treat maps more like normal messages.
-    for (int i = 0; i < message_generators_.size(); i++) {
+    for (int i = 0; i < file_->message_type_count(); i++) {
       message_generators_[i]->GenerateTypeRegistrations(printer);
     }
 
     printer->Outdent();
     printer->Print(
       "}\n"
       "\n"
       "}  // namespace\n");
   }
 
   // -----------------------------------------------------------------
 
   // ShutdownFile():  Deletes descriptors, default instances, etc. on shutdown.
   printer->Print(
     "\n"
     "void $shutdownfilename$() {\n",
     "shutdownfilename", GlobalShutdownFileName(file_->name()));
   printer->Indent();
 
-  for (int i = 0; i < message_generators_.size(); i++) {
+  for (int i = 0; i < file_->message_type_count(); i++) {
     message_generators_[i]->GenerateShutdownCode(printer);
   }
 
   printer->Outdent();
   printer->Print(
     "}\n\n");
 
   // -----------------------------------------------------------------
 
-  // Now generate the InitDefaults() function.
-  printer->Print(
-      "void $initdefaultsname$_impl() {\n"
-      "  GOOGLE_PROTOBUF_VERIFY_VERSION;\n\n"
-      "",
+  // Now generate the AddDescriptors() function.
+  PrintHandlingOptionalStaticInitializers(
+      file_, options_, printer,
+      // With static initializers.
+      // Note that we don't need any special synchronization in the following
+      // code
+      // because it is called at static init time before any threads exist.
+      "void $adddescriptorsname$() {\n"
+      "  static bool already_here = false;\n"
+      "  if (already_here) return;\n"
+      "  already_here = true;\n"
+      "  GOOGLE_PROTOBUF_VERIFY_VERSION;\n"
+      "\n",
+      // Without.
+      "void $adddescriptorsname$_impl() {\n"
+      "  GOOGLE_PROTOBUF_VERIFY_VERSION;\n"
+      "\n",
       // Vars.
-      "initdefaultsname", GlobalInitDefaultsName(file_->name()));
+      "adddescriptorsname", GlobalAddDescriptorsName(file_->name()));
 
   printer->Indent();
 
-  // Call the InitDefaults() methods for all of our dependencies, to make
+  // Call the AddDescriptors() methods for all of our dependencies, to make
   // sure they get added first.
   for (int i = 0; i < file_->dependency_count(); i++) {
     const FileDescriptor* dependency = file_->dependency(i);
     // Print the namespace prefix for the dependency.
     string add_desc_name = QualifiedFileLevelSymbol(
-        dependency->package(), GlobalInitDefaultsName(dependency->name()));
+        dependency->package(), GlobalAddDescriptorsName(dependency->name()));
     // Call its AddDescriptors function.
     printer->Print(
       "$name$();\n",
       "name", add_desc_name);
   }
 
-  // Force initialization of primitive values we depend on.
-  printer->Print("::google::protobuf::internal::InitProtobufDefaults();\n");
-
-  // Allocate and initialize default instances.  This can't be done lazily
-  // since default instances are returned by simple accessors and are used with
-  // extensions.  Speaking of which, we also register extensions at this time.
-  for (int i = 0; i < message_generators_.size(); i++) {
-    message_generators_[i]->GenerateDefaultInstanceAllocator(printer);
-  }
-  for (int i = 0; i < extension_generators_.size(); i++) {
-    extension_generators_[i]->GenerateRegistration(printer);
-  }
-  for (int i = 0; i < message_generators_.size(); i++) {
-    message_generators_[i]->GenerateDefaultInstanceInitializer(printer);
-  }
-  printer->Outdent();
-  printer->Print(
-      "}\n"
-      "\n"
-      "void $initdefaultsname$() {\n"
-      "  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);\n"
-      "  ::google::protobuf::GoogleOnceInit(&once, &$initdefaultsname$_impl);\n"
-      "}\n",
-      "initdefaultsname", GlobalInitDefaultsName(file_->name()));
-
-  // -----------------------------------------------------------------
-
-  // Now generate the AddDescriptors() function.
-  printer->Print(
-      "void $adddescriptorsname$_impl() {\n"
-      "  $initdefaultsname$();\n",
-      // Vars.
-      "adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
-      "initdefaultsname", GlobalInitDefaultsName(file_->name()));
-
-  printer->Indent();
   if (HasDescriptorMethods(file_, options_)) {
-    // Embed the descriptor.  We simply serialize the entire
-    // FileDescriptorProto
+    // Embed the descriptor.  We simply serialize the entire FileDescriptorProto
     // and embed it as a string literal, which is parsed and built into real
     // descriptors at initialization time.
     FileDescriptorProto file_proto;
     file_->CopyTo(&file_proto);
     string file_data;
     file_proto.SerializeToString(&file_data);
 
-    printer->Print("static const char descriptor[] = {\n");
-    printer->Indent();
-
 #ifdef _MSC_VER
     bool breakdown_large_file = true;
 #else
     bool breakdown_large_file = false;
 #endif
-    if (breakdown_large_file && file_data.size() > 66538) {
-      // Workaround for MSVC: "Error C1091: compiler limit: string exceeds 65535
-      // bytes in length". Declare a static array of characters rather than use
-      // a string literal. Only write 25 bytes per line.
+    // Workaround for MSVC: "Error C1091: compiler limit: string exceeds 65535
+    // bytes in length". Declare a static array of characters rather than use a
+    // string literal.
+    if (breakdown_large_file && file_data.size() > 65535) {
+      // This has to be explicitly marked as a signed char because the generated
+      // code puts negative values in the array, and sometimes plain char is
+      // unsigned. That implicit narrowing conversion is not allowed in C++11.
+      // <http://stackoverflow.com/questions/4434140/narrowing-conversions-in-c0x-is-it-just-me-or-does-this-sound-like-a-breakin>
+      // has details on why.
+      printer->Print(
+          "static const signed char descriptor[] = {\n");
+      printer->Indent();
+
+      // Only write 25 bytes per line.
       static const int kBytesPerLine = 25;
       for (int i = 0; i < file_data.size();) {
-        for (int j = 0; j < kBytesPerLine && i < file_data.size(); ++i, ++j) {
-          printer->Print("'$char$', ", "char",
-                         CEscape(file_data.substr(i, 1)));
-        }
-        printer->Print("\n");
+          for (int j = 0; j < kBytesPerLine && i < file_data.size(); ++i, ++j) {
+            printer->Print(
+                "$char$, ",
+                "char", SimpleItoa(file_data[i]));
+          }
+          printer->Print(
+              "\n");
       }
+
+      printer->Outdent();
+      printer->Print(
+          "};\n");
+
+      printer->Print(
+          "::google::protobuf::DescriptorPool::InternalAddGeneratedFile(descriptor, $size$);\n",
+          "size", SimpleItoa(file_data.size()));
+
     } else {
+      printer->Print(
+        "::google::protobuf::DescriptorPool::InternalAddGeneratedFile(");
+
       // Only write 40 bytes per line.
       static const int kBytesPerLine = 40;
       for (int i = 0; i < file_data.size(); i += kBytesPerLine) {
-        printer->Print("  \"$data$\"\n", "data",
-                       EscapeTrigraphs(CEscape(
-                           file_data.substr(i, kBytesPerLine))));
-      }
+        printer->Print("\n  \"$data$\"",
+                       "data",
+                       EscapeTrigraphs(
+                           CEscape(file_data.substr(i, kBytesPerLine))));
     }
-
-    printer->Outdent();
-    printer->Print("};\n");
     printer->Print(
-        "::google::protobuf::DescriptorPool::InternalAddGeneratedFile(\n"
-        "    descriptor, $size$);\n",
+        ", $size$);\n",
         "size", SimpleItoa(file_data.size()));
+    }
 
     // Call MessageFactory::InternalRegisterGeneratedFile().
     printer->Print(
       "::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(\n"
       "  \"$filename$\", &protobuf_RegisterTypes);\n",
       "filename", file_->name());
   }
 
-  // Call the AddDescriptors() methods for all of our dependencies, to make
-  // sure they get added first.
-  for (int i = 0; i < file_->dependency_count(); i++) {
-    const FileDescriptor* dependency = file_->dependency(i);
-    // Print the namespace prefix for the dependency.
-    string add_desc_name = QualifiedFileLevelSymbol(
-        dependency->package(), GlobalAddDescriptorsName(dependency->name()));
-    // Call its AddDescriptors function.
-    printer->Print("$adddescriptorsname$();\n", "adddescriptorsname",
-                   add_desc_name);
+  // Allocate and initialize default instances.  This can't be done lazily
+  // since default instances are returned by simple accessors and are used with
+  // extensions.  Speaking of which, we also register extensions at this time.
+  for (int i = 0; i < file_->message_type_count(); i++) {
+    message_generators_[i]->GenerateDefaultInstanceAllocator(printer);
+  }
+  for (int i = 0; i < file_->extension_count(); i++) {
+    extension_generators_[i]->GenerateRegistration(printer);
+  }
+  for (int i = 0; i < file_->message_type_count(); i++) {
+    message_generators_[i]->GenerateDefaultInstanceInitializer(printer);
   }
 
   printer->Print(
-      "::google::protobuf::internal::OnShutdown(&$shutdownfilename$);\n",
-      "shutdownfilename", GlobalShutdownFileName(file_->name()));
+    "::google::protobuf::internal::OnShutdown(&$shutdownfilename$);\n",
+    "shutdownfilename", GlobalShutdownFileName(file_->name()));
 
   printer->Outdent();
   printer->Print(
-      "}\n"
-      "\n"
-      "GOOGLE_PROTOBUF_DECLARE_ONCE($adddescriptorsname$_once_);\n"
-      "void $adddescriptorsname$() {\n"
-      "  ::google::protobuf::GoogleOnceInit(&$adddescriptorsname$_once_,\n"
-      "                 &$adddescriptorsname$_impl);\n"
-      "}\n",
-      "adddescriptorsname", GlobalAddDescriptorsName(file_->name()));
+    "}\n"
+    "\n");
 
-  if (!StaticInitializersForced(file_, options_)) {
-    printer->Print("#ifndef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER\n");
-  }
-  printer->Print(
+  PrintHandlingOptionalStaticInitializers(
+      file_, options_, printer,
       // With static initializers.
       "// Force AddDescriptors() to be called at static initialization time.\n"
       "struct StaticDescriptorInitializer_$filename$ {\n"
       "  StaticDescriptorInitializer_$filename$() {\n"
       "    $adddescriptorsname$();\n"
       "  }\n"
       "} static_descriptor_initializer_$filename$_;\n",
+      // Without.
+      "GOOGLE_PROTOBUF_DECLARE_ONCE($adddescriptorsname$_once_);\n"
+      "void $adddescriptorsname$() {\n"
+      "  ::google::protobuf::GoogleOnceInit(&$adddescriptorsname$_once_,\n"
+      "                 &$adddescriptorsname$_impl);\n"
+      "}\n",
       // Vars.
       "adddescriptorsname", GlobalAddDescriptorsName(file_->name()), "filename",
       FilenameIdentifier(file_->name()));
-  if (!StaticInitializersForced(file_, options_)) {
-    printer->Print("#endif  // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER\n");
-  }
 }
 
 void FileGenerator::GenerateNamespaceOpeners(io::Printer* printer) {
   if (package_parts_.size() > 0) printer->Print("\n");
 
   for (int i = 0; i < package_parts_.size(); i++) {
     printer->Print("namespace $part$ {\n",
                    "part", package_parts_[i]);
   }
 }
 
 void FileGenerator::GenerateNamespaceClosers(io::Printer* printer) {
   if (package_parts_.size() > 0) printer->Print("\n");
 
   for (int i = package_parts_.size() - 1; i >= 0; i--) {
     printer->Print("}  // namespace $part$\n",
                    "part", package_parts_[i]);
   }
 }
 
 void FileGenerator::GenerateForwardDeclarations(io::Printer* printer) {
   ForwardDeclarations decls;
   for (int i = 0; i < file_->dependency_count(); i++) {
     FileGenerator dependency(file_->dependency(i), options_);
     dependency.FillForwardDeclarations(&decls);
   }
   FillForwardDeclarations(&decls);
-  decls.Print(printer, options_);
+  decls.Print(printer);
 }
 
 void FileGenerator::FillForwardDeclarations(ForwardDeclarations* decls) {
   for (int i = 0; i < file_->public_dependency_count(); i++) {
     FileGenerator dependency(file_->public_dependency(i), options_);
     dependency.FillForwardDeclarations(decls);
   }
   for (int i = 0; i < package_parts_.size(); i++) {
     decls = decls->AddOrGetNamespace(package_parts_[i]);
   }
   // Generate enum definitions.
-  for (int i = 0; i < enum_generators_.size(); i++) {
+  for (int i = 0; i < file_->message_type_count(); i++) {
+    message_generators_[i]->FillEnumForwardDeclarations(&decls->enums());
+  }
+  for (int i = 0; i < file_->enum_type_count(); i++) {
     enum_generators_[i]->FillForwardDeclaration(&decls->enums());
   }
   // Generate forward declarations of classes.
-  for (int i = 0; i < message_generators_.size(); i++) {
+  for (int i = 0; i < file_->message_type_count(); i++) {
     message_generators_[i]->FillMessageForwardDeclarations(
         &decls->classes());
   }
 }
 
 void FileGenerator::GenerateTopHeaderGuard(io::Printer* printer,
                                            const string& filename_identifier) {
   // Generate top of header.
   printer->Print(
       "// Generated by the protocol buffer compiler.  DO NOT EDIT!\n"
@@ skipping 35 matching lines @@
     "#endif\n"
     "\n",
     "min_header_version",
       SimpleItoa(protobuf::internal::kMinHeaderVersionForProtoc),
     "protoc_version", SimpleItoa(GOOGLE_PROTOBUF_VERSION));
 
   // OK, it's now safe to #include other files.
   printer->Print(
     "#include <google/protobuf/arena.h>\n"
     "#include <google/protobuf/arenastring.h>\n"
-    "#include <google/protobuf/generated_message_util.h>\n"
-    "#include <google/protobuf/metadata.h>\n");
-
-  if (!message_generators_.empty()) {
+    "#include <google/protobuf/generated_message_util.h>\n");
+  if (UseUnknownFieldSet(file_, options_)) {
+    printer->Print(
+      "#include <google/protobuf/metadata.h>\n");
+  }
+  if (file_->message_type_count() > 0) {
     if (HasDescriptorMethods(file_, options_)) {
       printer->Print(
         "#include <google/protobuf/message.h>\n");
     } else {
       printer->Print(
         "#include <google/protobuf/message_lite.h>\n");
     }
   }
   printer->Print(
-    "#include <google/protobuf/repeated_field.h>"
-    "  // IWYU pragma: export\n"
-    "#include <google/protobuf/extension_set.h>"
-    "  // IWYU pragma: export\n");
+    "#include <google/protobuf/repeated_field.h>\n"
+    "#include <google/protobuf/extension_set.h>\n");
   if (HasMapFields(file_)) {
     printer->Print(
         "#include <google/protobuf/map.h>\n");
     if (HasDescriptorMethods(file_, options_)) {
       printer->Print(
           "#include <google/protobuf/map_field_inl.h>\n");
     } else {
       printer->Print(
           "#include <google/protobuf/map_field_lite.h>\n");
     }
   }
 
   if (HasEnumDefinitions(file_)) {
     if (HasDescriptorMethods(file_, options_)) {
       printer->Print(
           "#include <google/protobuf/generated_enum_reflection.h>\n");
     } else {
       printer->Print(
           "#include <google/protobuf/generated_enum_util.h>\n");
     }
   }
 
   if (HasGenericServices(file_, options_)) {
     printer->Print(
       "#include <google/protobuf/service.h>\n");
   }
 
-  if (UseUnknownFieldSet(file_, options_) && !message_generators_.empty()) {
+  if (UseUnknownFieldSet(file_, options_) && file_->message_type_count() > 0) {
     printer->Print(
       "#include <google/protobuf/unknown_field_set.h>\n");
   }
 
 
   if (IsAnyMessage(file_)) {
     printer->Print(
       "#include <google/protobuf/any.h>\n");
   }
 }
 
 void FileGenerator::GenerateMetadataPragma(io::Printer* printer,
                                            const string& info_path) {
   if (!info_path.empty() && !options_.annotation_pragma_name.empty() &&
       !options_.annotation_guard_name.empty()) {
     printer->Print(
         "#ifdef $guard$\n"
         "#pragma $pragma$ \"$info_path$\"\n"
         "#endif  // $guard$\n",
         "guard", options_.annotation_guard_name, "pragma",
         options_.annotation_pragma_name, "info_path", info_path);
   }
 }
 
 void FileGenerator::GenerateDependencyIncludes(io::Printer* printer) {
-  std::set<string> public_import_names;
+  set<string> public_import_names;
   for (int i = 0; i < file_->public_dependency_count(); i++) {
     public_import_names.insert(file_->public_dependency(i)->name());
   }
 
   for (int i = 0; i < file_->dependency_count(); i++) {
     const bool use_system_include = IsWellKnownMessage(file_->dependency(i));
     const string& name = file_->dependency(i)->name();
     bool public_import = (public_import_names.count(name) != 0);
 
 
     printer->Print(
       "#include $left$$dependency$.pb.h$right$$iwyu$\n",
       "dependency", StripProto(name),
       "iwyu", (public_import) ? "  // IWYU pragma: export" : "",
       "left", use_system_include ? "<" : "\"",
       "right", use_system_include ? ">" : "\"");
   }
 }
 
 void FileGenerator::GenerateGlobalStateFunctionDeclarations(
     io::Printer* printer) {
   // Forward-declare the AddDescriptors, AssignDescriptors, and ShutdownFile
   // functions, so that we can declare them to be friends of each class.
   printer->Print(
-      "\n"
-      "// Internal implementation detail -- do not call these.\n"
-      "void $dllexport_decl$$adddescriptorsname$();\n"
-      "void $dllexport_decl$$initdefaultsname$();\n",
-      "initdefaultsname", GlobalInitDefaultsName(file_->name()),
-      "adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
-      "dllexport_decl",
-      options_.dllexport_decl.empty() ? "" : options_.dllexport_decl + " ");
+    "\n"
+    "// Internal implementation detail -- do not call these.\n"
+    "void $dllexport_decl$$adddescriptorsname$();\n",
+    "adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
+    "dllexport_decl",
+    options_.dllexport_decl.empty() ? "" : options_.dllexport_decl + " ");
+
+  printer->Print(
+    // Note that we don't put dllexport_decl on these because they are only
+    // called by the .pb.cc file in which they are defined.
+    "void $assigndescriptorsname$();\n"
+    "void $shutdownfilename$();\n"
+    "\n",
+    "assigndescriptorsname", GlobalAssignDescriptorsName(file_->name()),
+    "shutdownfilename", GlobalShutdownFileName(file_->name()));
+}
+
+void FileGenerator::GenerateMessageForwardDeclarations(io::Printer* printer) {
+  map<string, const Descriptor*> classes;
+  for (int i = 0; i < file_->message_type_count(); i++) {
+    message_generators_[i]->FillMessageForwardDeclarations(&classes);
+  }
+  for (map<string, const Descriptor *>::const_iterator it = classes.begin(),
+                                                       end = classes.end();
+       it != end; ++it) {
+    printer->Print("class $classname$;\n", "classname", it->first);
+    printer->Annotate("classname", it->second);
+  }
 }
 
 void FileGenerator::GenerateMessageDefinitions(io::Printer* printer) {
   // Generate class definitions.
-  for (int i = 0; i < message_generators_.size(); i++) {
+  for (int i = 0; i < file_->message_type_count(); i++) {
     if (i > 0) {
       printer->Print("\n");
       printer->Print(kThinSeparator);
       printer->Print("\n");
     }
     message_generators_[i]->GenerateClassDefinition(printer);
   }
 }
 
 void FileGenerator::GenerateEnumDefinitions(io::Printer* printer) {
   // Generate enum definitions.
-  for (int i = 0; i < enum_generators_.size(); i++) {
+  for (int i = 0; i < file_->message_type_count(); i++) {
+    message_generators_[i]->GenerateEnumDefinitions(printer);
+  }
+  for (int i = 0; i < file_->enum_type_count(); i++) {
     enum_generators_[i]->GenerateDefinition(printer);
   }
 }
 
 void FileGenerator::GenerateServiceDefinitions(io::Printer* printer) {
   if (HasGenericServices(file_, options_)) {
     // Generate service definitions.
-    for (int i = 0; i < service_generators_.size(); i++) {
+    for (int i = 0; i < file_->service_count(); i++) {
       if (i > 0) {
         printer->Print("\n");
         printer->Print(kThinSeparator);
         printer->Print("\n");
       }
       service_generators_[i]->GenerateDeclarations(printer);
     }
 
     printer->Print("\n");
     printer->Print(kThickSeparator);
     printer->Print("\n");
   }
 }
 
 void FileGenerator::GenerateExtensionIdentifiers(io::Printer* printer) {
-  // Declare extension identifiers. These are in global scope and so only
-  // the global scope extensions.
+  // Declare extension identifiers.
   for (int i = 0; i < file_->extension_count(); i++) {
-    extension_generators_owner_[i]->GenerateDeclaration(printer);
+    extension_generators_[i]->GenerateDeclaration(printer);
   }
 }
 
 void FileGenerator::GenerateInlineFunctionDefinitions(io::Printer* printer) {
   // An aside about inline functions in .proto.h mode:
   //
   // The PROTOBUF_INLINE_NOT_IN_HEADERS symbol controls conditionally
   // moving much of the inline functions to the .pb.cc file, which can be a
   // significant performance benefit for compilation time, at the expense
   // of non-inline function calls.
@@ skipping 20 matching lines @@
   //  3. Functions on the message that are used by the dependent base: the
   //     dependent base class down casts itself to the message
   //     implementation class to access these functions (the has_* bit
   //     manipulation functions). Unlike #1, these functions must
   //     unconditionally remain in the header. These are emitted by
   //     GenerateDependentInlineMethods, even though they are not actually
   //     dependent.
 
   printer->Print("#if !PROTOBUF_INLINE_NOT_IN_HEADERS\n");
   // Generate class inline methods.
-  for (int i = 0; i < message_generators_.size(); i++) {
+  for (int i = 0; i < file_->message_type_count(); i++) {
     if (i > 0) {
       printer->Print(kThinSeparator);
       printer->Print("\n");
     }
     message_generators_[i]->GenerateInlineMethods(printer,
                                                   /* is_inline = */ true);
   }
   printer->Print("#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS\n");
 
-  for (int i = 0; i < message_generators_.size(); i++) {
+  for (int i = 0; i < file_->message_type_count(); i++) {
     if (i > 0) {
       printer->Print(kThinSeparator);
       printer->Print("\n");
     }
     // Methods of the dependent base class must always be inline in the header.
     message_generators_[i]->GenerateDependentInlineMethods(printer);
   }
 }
 
 void FileGenerator::GenerateProto2NamespaceEnumSpecializations(
     io::Printer* printer) {
   // Emit GetEnumDescriptor specializations into google::protobuf namespace:
   if (HasEnumDefinitions(file_)) {
     // The SWIG conditional is to avoid a null-pointer dereference
     // (bug 1984964) in swig-1.3.21 resulting from the following syntax:
     //   namespace X { void Y<Z::W>(); }
     // which appears in GetEnumDescriptor() specializations.
     printer->Print(
         "\n"
         "#ifndef SWIG\n"
         "namespace google {\nnamespace protobuf {\n"
         "\n");
-    for (int i = 0; i < enum_generators_.size(); i++) {
+    for (int i = 0; i < file_->message_type_count(); i++) {
+      message_generators_[i]->GenerateGetEnumDescriptorSpecializations(printer);
+    }
+    for (int i = 0; i < file_->enum_type_count(); i++) {
       enum_generators_[i]->GenerateGetEnumDescriptorSpecializations(printer);
     }
     printer->Print(
         "\n"
         "}  // namespace protobuf\n}  // namespace google\n"
         "#endif  // SWIG\n");
   }
 }
 
 }  // namespace cpp
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google