Sync from Piper @482325250

PROTOBUF_SYNC_PIPER

src/google/protobuf/compiler/command_line_interface.cc

@@ -425,7 +425,7 @@ class CommandLineInterface::GeneratorContextImpl : public GeneratorContext {
   // The files_ field maps from path keys to file content values. It's a map
   // instead of an unordered_map so that files are written in order (good when
   // writing zips).
-  absl::flat_hash_map<std::string, std::string> files_;
+  std::map<std::string, std::string> files_;
   const std::vector<const FileDescriptor*>& parsed_files_;
   bool had_error_;
 };
@@ -1493,7 +1493,7 @@ CommandLineInterface::ParseArgumentStatus CommandLineInterface::ParseArguments(
 
   // Make sure each plugin option has a matching plugin output.
   bool foundUnknownPluginOption = false;
-  for (absl::flat_hash_map<std::string, std::string>::const_iterator i =
+  for (std::map<std::string, std::string>::const_iterator i =
            plugin_parameters_.begin();
        i != plugin_parameters_.end(); ++i) {
     if (plugins_.find(i->first) != plugins_.end()) {

src/google/protobuf/compiler/command_line_interface.h

@@ -367,9 +367,9 @@ class PROTOC_EXPORT CommandLineInterface {
   // flag. For example, if the user invokes the compiler with:
   //   protoc --foo_out=outputdir --foo_opt=enable_bar ...
   // Then there will be an entry ("--foo_out", "enable_bar") in this map.
-  absl::flat_hash_map<std::string, std::string> generator_parameters_;
+  std::map<std::string, std::string> generator_parameters_;
   // Similar to generator_parameters_, but stores the parameters for plugins.
-  absl::flat_hash_map<std::string, std::string> plugin_parameters_;
+  std::map<std::string, std::string> plugin_parameters_;
 
   // See AllowPlugins().  If this is empty, plugins aren't allowed.
   std::string plugin_prefix_;
@@ -377,7 +377,7 @@ class PROTOC_EXPORT CommandLineInterface {
   // Maps specific plugin names to files.  When executing a plugin, this map
   // is searched first to find the plugin executable.  If not found here, the
   // PATH (or other OS-specific search strategy) is searched.
-  absl::flat_hash_map<std::string, std::string> plugins_;
+  std::map<std::string, std::string> plugins_;
 
   // Stuff parsed from command line.
   enum Mode {

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

@@ -36,7 +36,6 @@
 
 #include "google/protobuf/io/printer.h"
 #include "google/protobuf/wire_format.h"
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/cpp/field.h"
 #include "google/protobuf/compiler/cpp/helpers.h"
 
@@ -48,7 +47,7 @@ namespace cpp {
 namespace {
 
 void SetEnumVariables(const FieldDescriptor* descriptor,
-                      absl::flat_hash_map<std::string, std::string>* variables,
+                      std::map<std::string, std::string>* variables,
                       const Options& options) {
   SetCommonFieldVariables(descriptor, variables, options);
   const EnumValueDescriptor* default_value = descriptor->default_value_enum();

src/google/protobuf/compiler/cpp/extension.h

@@ -38,7 +38,6 @@
 #include <map>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/cpp/options.h"
 #include "google/protobuf/port.h"
 
@@ -85,7 +84,7 @@ class ExtensionGenerator {
   Options options_;
   MessageSCCAnalyzer* scc_analyzer_;
 
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
 };
 
 }  // namespace cpp

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

@@ -38,7 +38,6 @@
 #include <memory>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/substitute.h"
@@ -63,12 +62,12 @@ using internal::WireFormat;
 
 namespace {
 
-void MaySetAnnotationVariable(
+void MaySetAnnotationVariable(const Options& options,
-    const Options& options, absl::string_view annotation_name,
+                              absl::string_view annotation_name,
-    absl::string_view substitute_template_prefix,
+                              absl::string_view substitute_template_prefix,
-    absl::string_view prepared_template, int field_index,
+                              absl::string_view prepared_template,
-    absl::string_view access_type,
+                              int field_index, absl::string_view access_type,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+                              std::map<std::string, std::string>* variables) {
   if (options.field_listener_options.forbidden_field_listener_events.count(
           std::string(annotation_name)))
     return;
@@ -125,9 +124,9 @@ std::string GenerateTemplateForSingleString(const FieldDescriptor* descriptor,
 
 }  // namespace
 
-void AddAccessorAnnotations(
+void AddAccessorAnnotations(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, const Options& options,
+                            const Options& options,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+                            std::map<std::string, std::string>* variables) {
   // Can be expanded to include more specific calls, for example, for arena or
   // clear calls.
   static constexpr const char* kAccessorsAnnotations[] = {
@@ -262,7 +261,7 @@ absl::flat_hash_map<std::string, std::string> FieldVars(
 
   // TODO(b/245791219): Refactor AddAccessorAnnotations to avoid this
   // workaround.
-  absl::flat_hash_map<std::string, std::string> workaround = {
+  std::map<std::string, std::string> workaround = {
       {"field", vars["field"]},
       {"tracker", "Impl_::_tracker_"},
   };
@@ -274,10 +273,9 @@ absl::flat_hash_map<std::string, std::string> FieldVars(
   return vars;
 }
 
-void SetCommonFieldVariables(
+void SetCommonFieldVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                             std::map<std::string, std::string>* variables,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                             const Options& options) {
-    const Options& options) {
   SetCommonMessageDataVariables(descriptor->containing_type(), variables);
 
   for (auto& pair : FieldVars(descriptor, options)) {
@@ -296,14 +294,14 @@ absl::flat_hash_map<std::string, std::string> OneofFieldVars(
 
 void SetCommonOneofFieldVariables(
     const FieldDescriptor* descriptor,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+    std::map<std::string, std::string>* variables) {
   for (auto& pair : OneofFieldVars(descriptor)) {
     variables->emplace(pair);
   }
 }
 
 void FieldGenerator::SetHasBitIndex(int32_t has_bit_index) {
-  if (!internal::cpp::HasHasbit(descriptor_) || has_bit_index < 0) {
+  if (!internal::cpp::HasHasbit(descriptor_)) {
     GOOGLE_CHECK_EQ(has_bit_index, -1);
     return;
   }

src/google/protobuf/compiler/cpp/field.h

@@ -41,7 +41,6 @@
 #include <string>
 
 #include "google/protobuf/descriptor.h"
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/cpp/helpers.h"
 #include "google/protobuf/compiler/cpp/options.h"
 
@@ -68,14 +67,13 @@ absl::flat_hash_map<std::string, std::string> OneofFieldVars(
 // field code generators.
 // ['name', 'index', 'number', 'classname', 'declared_type', 'tag_size',
 // 'deprecation'].
-void SetCommonFieldVariables(
+void SetCommonFieldVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                             std::map<std::string, std::string>* variables,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                             const Options& options);
-    const Options& options);
 
 void SetCommonOneofFieldVariables(
     const FieldDescriptor* descriptor,
-    absl::flat_hash_map<std::string, std::string>* variables);
+    std::map<std::string, std::string>* variables);
 
 class FieldGenerator {
  public:
@@ -228,7 +226,7 @@ class FieldGenerator {
  protected:
   const FieldDescriptor* descriptor_;
   const Options& options_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
 };
 
 // Convenience class which constructs FieldGenerators for a Descriptor.

src/google/protobuf/compiler/cpp/file.h

@@ -44,7 +44,6 @@
 
 #include "google/protobuf/stubs/common.h"
 #include "google/protobuf/compiler/scc.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "google/protobuf/compiler/cpp/enum.h"
 #include "google/protobuf/compiler/cpp/extension.h"
@@ -196,7 +195,7 @@ class FileGenerator {
   // This member is unused and should be deleted once all old-style variable
   // maps are gone.
   // TODO(b/245791219)
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
 
   // Contains the post-order walk of all the messages (and child messages) in
   // this file. If you need a pre-order walk just reverse iterate.

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

@@ -252,7 +252,7 @@ absl::flat_hash_map<std::string, std::string> MessageVars(
 
 void SetCommonMessageDataVariables(
     const Descriptor* descriptor,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+    std::map<std::string, std::string>* variables) {
   for (auto& pair : MessageVars(descriptor)) {
     variables->emplace(pair);
   }
@@ -286,9 +286,9 @@ absl::flat_hash_map<std::string, std::string> UnknownFieldsVars(
   };
 }
 
-void SetUnknownFieldsVariable(
+void SetUnknownFieldsVariable(const Descriptor* descriptor,
-    const Descriptor* descriptor, const Options& options,
+                              const Options& options,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+                              std::map<std::string, std::string>* variables) {
   for (auto& pair : UnknownFieldsVars(descriptor, options)) {
     variables->emplace(pair);
   }

src/google/protobuf/compiler/cpp/helpers.h

@@ -94,14 +94,14 @@ absl::flat_hash_map<std::string, std::string> MessageVars(
 // Variables to access message data from the message scope.
 void SetCommonMessageDataVariables(
     const Descriptor* descriptor,
-    absl::flat_hash_map<std::string, std::string>* variables);
+    std::map<std::string, std::string>* variables);
 
 absl::flat_hash_map<std::string, std::string> UnknownFieldsVars(
     const Descriptor* desc, const Options& opts);
 
-void SetUnknownFieldsVariable(
+void SetUnknownFieldsVariable(const Descriptor* descriptor,
-    const Descriptor* descriptor, const Options& options,
+                              const Options& options,
-    absl::flat_hash_map<std::string, std::string>* variables);
+                              std::map<std::string, std::string>* variables);
 
 bool GetBootstrapBasename(const Options& options, const std::string& basename,
                           std::string* bootstrap_basename);
@@ -794,7 +794,7 @@ class PROTOC_EXPORT Formatter {
  public:
   explicit Formatter(io::Printer* printer) : printer_(printer) {}
   Formatter(io::Printer* printer,
-            const absl::flat_hash_map<std::string, std::string>& vars)
+            const std::map<std::string, std::string>& vars)
       : printer_(printer), vars_(vars) {}
 
   template <typename T>
@@ -802,7 +802,7 @@ class PROTOC_EXPORT Formatter {
     vars_[key] = ToString(value);
   }
 
-  void AddMap(const absl::flat_hash_map<std::string, std::string>& vars) {
+  void AddMap(const std::map<std::string, std::string>& vars) {
     for (const auto& keyval : vars) vars_[keyval.first] = keyval.second;
   }
 
@@ -844,12 +844,12 @@ class PROTOC_EXPORT Formatter {
 
    private:
     Formatter* format_;
-    absl::flat_hash_map<std::string, std::string> vars_;
+    std::map<std::string, std::string> vars_;
   };
 
  private:
   io::Printer* printer_;
-  absl::flat_hash_map<std::string, std::string> vars_;
+  std::map<std::string, std::string> vars_;
 
   // Convenience overloads to accept different types as arguments.
   static std::string ToString(const std::string& s) { return s; }

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

@@ -31,19 +31,17 @@
 #include "google/protobuf/compiler/cpp/map_field.h"
 
 #include "google/protobuf/wire_format.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/ascii.h"
-#include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/cpp/helpers.h"
+#include "absl/strings/str_cat.h"
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace cpp {
-void SetMessageVariables(
+void SetMessageVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                         std::map<std::string, std::string>* variables,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                         const Options& options) {
-    const Options& options) {
   SetCommonFieldVariables(descriptor, variables, options);
   (*variables)["type"] = ClassName(descriptor->message_type(), false);
   (*variables)["full_name"] = descriptor->full_name();

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

@@ -278,9 +278,9 @@ bool HasHasMethod(const FieldDescriptor* field) {
 
 // Collects map entry message type information.
 void CollectMapInfo(const Options& options, const Descriptor* descriptor,
-                    absl::flat_hash_map<std::string, std::string>* variables) {
+                    std::map<std::string, std::string>* variables) {
   GOOGLE_CHECK(IsMapEntryMessage(descriptor));
-  absl::flat_hash_map<std::string, std::string>& vars = *variables;
+  std::map<std::string, std::string>& vars = *variables;
   const FieldDescriptor* key = descriptor->map_key();
   const FieldDescriptor* val = descriptor->map_value();
   vars["key_cpp"] = PrimitiveTypeName(options, key->cpp_type());
@@ -429,7 +429,7 @@ class ColdChunkSkipper {
   const std::vector<int>& has_bit_indices_;
   const AccessInfoMap* access_info_map_;
   const double cold_threshold_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   int limit_chunk_ = -1;
 };
 
@@ -640,11 +640,11 @@ absl::flat_hash_map<std::string, std::string> ClassVars(const Descriptor* desc,
 
 // ===================================================================
 
-MessageGenerator::MessageGenerator(
+MessageGenerator::MessageGenerator(const Descriptor* descriptor,
-    const Descriptor* descriptor,
+                                   const std::map<std::string, std::string>&,
-    const absl::flat_hash_map<std::string, std::string>&,
+                                   int index_in_file_messages,
-    int index_in_file_messages, const Options& options,
+                                   const Options& options,
-    MessageSCCAnalyzer* scc_analyzer)
+                                   MessageSCCAnalyzer* scc_analyzer)
     : descriptor_(descriptor),
       index_in_file_messages_(index_in_file_messages),
       options_(options),
@@ -779,7 +779,7 @@ void MessageGenerator::GenerateFieldAccessorDeclarations(io::Printer* p) {
     for (auto field : ordered_fields) {
       Formatter::SaveState save(&format);
 
-      absl::flat_hash_map<std::string, std::string> vars;
+      std::map<std::string, std::string> vars;
       SetCommonFieldVariables(field, &vars, options_);
       auto v = p->WithVars(std::move(vars));
       format("  ${1$$2$$}$ = $number$,\n", field, FieldConstantName(field));
@@ -1290,7 +1290,7 @@ void MessageGenerator::GenerateClassDefinition(io::Printer* p) {
   Formatter format(p);
 
   if (IsMapEntryMessage(descriptor_)) {
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     CollectMapInfo(options_, descriptor_, &vars);
     vars["lite"] =
         HasDescriptorMethods(descriptor_->file(), options_) ? "" : "Lite";
@@ -3749,7 +3749,7 @@ void MessageGenerator::GenerateSerializeOneField(io::Printer* p,
 
 void MessageGenerator::GenerateSerializeOneExtensionRange(
     io::Printer* p, const Descriptor::ExtensionRange* range) {
-  absl::flat_hash_map<std::string, std::string> vars = variables_;
+  std::map<std::string, std::string> vars = variables_;
   vars["start"] = absl::StrCat(range->start);
   vars["end"] = absl::StrCat(range->end);
   Formatter format(p, vars);

src/google/protobuf/compiler/cpp/message.h

@@ -61,7 +61,7 @@ namespace cpp {
 class MessageGenerator {
  public:
   MessageGenerator(const Descriptor* descriptor,
-                   const absl::flat_hash_map<std::string, std::string>& ignored,
+                   const std::map<std::string, std::string>& ignored,
                    int index_in_file_messages, const Options& options,
                    MessageSCCAnalyzer* scc_analyzer);
 
@@ -214,7 +214,7 @@ class MessageGenerator {
 
   MessageSCCAnalyzer* scc_analyzer_;
 
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
 
 };
 

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

@@ -35,10 +35,9 @@
 #include "google/protobuf/compiler/cpp/message_field.h"
 
 #include "google/protobuf/io/printer.h"
-#include "absl/container/flat_hash_map.h"
-#include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/cpp/field.h"
 #include "google/protobuf/compiler/cpp/helpers.h"
+#include "absl/strings/str_cat.h"
 
 namespace google {
 namespace protobuf {
@@ -56,10 +55,9 @@ std::string ReinterpretCast(const std::string& type,
   }
 }
 
-void SetMessageVariables(
+void SetMessageVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, const Options& options,
+                         const Options& options, bool implicit_weak,
-    bool implicit_weak,
+                         std::map<std::string, std::string>* variables) {
-    absl::flat_hash_map<std::string, std::string>* variables) {
   SetCommonFieldVariables(descriptor, variables, options);
   (*variables)["type"] = FieldMessageTypeName(descriptor, options);
   (*variables)["casted_member"] = ReinterpretCast(

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

@@ -38,7 +38,6 @@
 #include <vector>
 
 #include "google/protobuf/wire_format.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/cpp/helpers.h"
 #include "google/protobuf/generated_message_tctable_gen.h"
@@ -110,7 +109,7 @@ ParseFunctionGenerator::ParseFunctionGenerator(
     const std::vector<int>& has_bit_indices,
     const std::vector<int>& inlined_string_indices, const Options& options,
     MessageSCCAnalyzer* scc_analyzer,
-    const absl::flat_hash_map<std::string, std::string>& vars)
+    const std::map<std::string, std::string>& vars)
     : descriptor_(descriptor),
       scc_analyzer_(scc_analyzer),
       options_(options),

src/google/protobuf/compiler/cpp/parse_function_generator.h

@@ -38,7 +38,6 @@
 #include "google/protobuf/io/printer.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/wire_format_lite.h"
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/cpp/helpers.h"
 #include "google/protobuf/compiler/cpp/options.h"
 #include "google/protobuf/generated_message_tctable_gen.h"
@@ -52,12 +51,12 @@ namespace cpp {
 // (and any associated supporting members).
 class ParseFunctionGenerator {
  public:
-  ParseFunctionGenerator(
+  ParseFunctionGenerator(const Descriptor* descriptor, int max_has_bit_index,
-      const Descriptor* descriptor, int max_has_bit_index,
+                         const std::vector<int>& has_bit_indices,
-      const std::vector<int>& has_bit_indices,
+                         const std::vector<int>& inlined_string_indices,
-      const std::vector<int>& inlined_string_indices, const Options& options,
+                         const Options& options,
-      MessageSCCAnalyzer* scc_analyzer,
+                         MessageSCCAnalyzer* scc_analyzer,
-      const absl::flat_hash_map<std::string, std::string>& vars);
+                         const std::map<std::string, std::string>& vars);
 
   // Emits class-level method declarations to `printer`:
   void GenerateMethodDecls(io::Printer* printer);
@@ -127,7 +126,7 @@ class ParseFunctionGenerator {
   const Descriptor* descriptor_;
   MessageSCCAnalyzer* scc_analyzer_;
   const Options& options_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   std::unique_ptr<internal::TailCallTableInfo> tc_table_info_;
   std::vector<int> inlined_string_indices_;
   const std::vector<const FieldDescriptor*> ordered_fields_;

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

@@ -36,7 +36,6 @@
 
 #include "google/protobuf/io/printer.h"
 #include "google/protobuf/wire_format.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/cpp/helpers.h"
 
@@ -99,10 +98,9 @@ int FixedSize(FieldDescriptor::Type type) {
   return -1;
 }
 
-void SetPrimitiveVariables(
+void SetPrimitiveVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                           std::map<std::string, std::string>* variables,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                           const Options& options) {
-    const Options& options) {
   SetCommonFieldVariables(descriptor, variables, options);
   (*variables)["type"] = PrimitiveTypeName(options, descriptor->cpp_type());
   (*variables)["default"] = DefaultValue(options, descriptor);

src/google/protobuf/compiler/cpp/service.h

@@ -39,7 +39,6 @@
 #include <string>
 
 #include "google/protobuf/descriptor.h"
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/cpp/options.h"
 #include "google/protobuf/io/printer.h"
 
@@ -51,7 +50,7 @@ class ServiceGenerator {
  public:
   // See generator.cc for the meaning of dllexport_decl.
   ServiceGenerator(const ServiceDescriptor* descriptor,
-                   const absl::flat_hash_map<std::string, std::string>& vars,
+                   const std::map<std::string, std::string>& vars,
                    const Options& options)
       : descriptor_(descriptor), options_(&options), vars_(vars) {
     vars_["classname"] = descriptor_->name();
@@ -99,7 +98,7 @@ class ServiceGenerator {
 
   const ServiceDescriptor* descriptor_;
   const Options* options_;
-  absl::flat_hash_map<std::string, std::string> vars_;
+  std::map<std::string, std::string> vars_;
 
   int index_in_metadata_;
 

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

@@ -34,7 +34,6 @@
 
 #include "google/protobuf/compiler/cpp/string_field.h"
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/cpp/helpers.h"
 #include "google/protobuf/descriptor.pb.h"
@@ -46,10 +45,9 @@ namespace cpp {
 
 namespace {
 
-void SetStringVariables(
+void SetStringVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                        std::map<std::string, std::string>* variables,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                        const Options& options) {
-    const Options& options) {
   SetCommonFieldVariables(descriptor, variables, options);
 
   const std::string kNS = "::" + ProtobufNamespace(options) + "::internal::";

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

@@ -52,7 +52,7 @@ namespace compiler {
 namespace csharp {
 
 void FieldGeneratorBase::SetCommonFieldVariables(
-    absl::flat_hash_map<std::string, std::string>* variables) {
+    std::map<std::string, std::string>* variables) {
   // Note: this will be valid even though the tag emitted for packed and unpacked versions of
   // repeated fields varies by wire format. The wire format is encoded in the bottom 3 bits, which
   // never effects the tag size.
@@ -124,7 +124,7 @@ void FieldGeneratorBase::SetCommonFieldVariables(
 }
 
 void FieldGeneratorBase::SetCommonOneofFieldVariables(
-    absl::flat_hash_map<std::string, std::string>* variables) {
+    std::map<std::string, std::string>* variables) {
   (*variables)["oneof_name"] = oneof_name();
   if (SupportsPresenceApi(descriptor_)) {
     (*variables)["has_property_check"] = "Has" + property_name();

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

@@ -34,7 +34,6 @@
 #include <string>
 
 #include "google/protobuf/compiler/code_generator.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_replace.h"
@@ -78,7 +77,7 @@ class FieldGeneratorBase : public SourceGeneratorBase {
  protected:
   const FieldDescriptor* descriptor_;
   const int presenceIndex_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
 
   void AddDeprecatedFlag(io::Printer* printer);
   void AddNullCheck(io::Printer* printer);
@@ -86,7 +85,7 @@ class FieldGeneratorBase : public SourceGeneratorBase {
 
   void AddPublicMemberAttributes(io::Printer* printer);
   void SetCommonOneofFieldVariables(
-      absl::flat_hash_map<std::string, std::string>* variables);
+      std::map<std::string, std::string>* variables);
 
   std::string oneof_property_name();
   std::string oneof_case_name(); 
@@ -102,8 +101,7 @@ class FieldGeneratorBase : public SourceGeneratorBase {
   std::string capitalized_type_name();
 
  private:
-  void SetCommonFieldVariables(
+  void SetCommonFieldVariables(std::map<std::string, std::string>* variables);
-      absl::flat_hash_map<std::string, std::string>* variables);
   std::string GetStringDefaultValueInternal(const FieldDescriptor* descriptor);
   std::string GetBytesDefaultValueInternal(const FieldDescriptor* descriptor);
 };

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

@@ -35,14 +35,13 @@
 #include <sstream>
 
 #include "google/protobuf/compiler/code_generator.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/csharp/csharp_doc_comment.h"
 #include "google/protobuf/compiler/csharp/csharp_enum.h"
 #include "google/protobuf/compiler/csharp/csharp_field_base.h"
 #include "google/protobuf/compiler/csharp/csharp_helpers.h"
-#include "google/protobuf/compiler/csharp/csharp_options.h"
 #include "google/protobuf/compiler/csharp/names.h"
+#include "google/protobuf/compiler/csharp/csharp_options.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/io/printer.h"
@@ -115,7 +114,7 @@ void MessageGenerator::AddSerializableAttribute(io::Printer* printer) {
 }
 
 void MessageGenerator::Generate(io::Printer* printer) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["class_name"] = class_name();
   vars["access_level"] = class_access_level();
 
@@ -377,7 +376,7 @@ bool MessageGenerator::HasNestedGeneratedTypes()
 }
 
 void MessageGenerator::GenerateCloningCode(io::Printer* printer) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   WriteGeneratedCodeAttributes(printer);
   vars["class_name"] = class_name();
     printer->Print(
@@ -441,30 +440,32 @@ void MessageGenerator::GenerateFreezingCode(io::Printer* printer) {
 }
 
 void MessageGenerator::GenerateFrameworkMethods(io::Printer* printer) {
-  absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
-  vars["class_name"] = class_name();
+    vars["class_name"] = class_name();
 
-  // Equality
+    // Equality
-  WriteGeneratedCodeAttributes(printer);
+    WriteGeneratedCodeAttributes(printer);
-  printer->Print(vars,
+    printer->Print(
-                 "public override bool Equals(object other) {\n"
+        vars,
-                 "  return Equals(other as $class_name$);\n"
+        "public override bool Equals(object other) {\n"
-                 "}\n\n");
+        "  return Equals(other as $class_name$);\n"
-  WriteGeneratedCodeAttributes(printer);
+        "}\n\n");
-  printer->Print(vars,
+    WriteGeneratedCodeAttributes(printer);
-                 "public bool Equals($class_name$ other) {\n"
+    printer->Print(
-                 "  if (ReferenceEquals(other, null)) {\n"
+        vars,
-                 "    return false;\n"
+        "public bool Equals($class_name$ other) {\n"
-                 "  }\n"
+        "  if (ReferenceEquals(other, null)) {\n"
-                 "  if (ReferenceEquals(other, this)) {\n"
+        "    return false;\n"
-                 "    return true;\n"
+        "  }\n"
-                 "  }\n");
+        "  if (ReferenceEquals(other, this)) {\n"
-  printer->Indent();
+        "    return true;\n"
-  for (int i = 0; i < descriptor_->field_count(); i++) {
+        "  }\n");
-    std::unique_ptr<FieldGeneratorBase> generator(
+    printer->Indent();
-        CreateFieldGeneratorInternal(descriptor_->field(i)));
+    for (int i = 0; i < descriptor_->field_count(); i++) {
-    generator->WriteEquals(printer);
+      std::unique_ptr<FieldGeneratorBase> generator(
-  }
+            CreateFieldGeneratorInternal(descriptor_->field(i)));
+        generator->WriteEquals(printer);
+    }
     for (int i = 0; i < descriptor_->real_oneof_decl_count(); i++) {
       printer->Print("if ($property_name$Case != other.$property_name$Case) return false;\n",
           "property_name", UnderscoresToCamelCase(descriptor_->oneof_decl(i)->name(), true));
@@ -606,7 +607,7 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
   // Note:  These are separate from GenerateMessageSerializationMethods()
   //   because they need to be generated even for messages that are optimized
   //   for code size.
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["class_name"] = class_name();
 
   WriteGeneratedCodeAttributes(printer);
@@ -686,7 +687,7 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
 }
 
 void MessageGenerator::GenerateMainParseLoop(io::Printer* printer, bool use_parse_context) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["maybe_ref_input"] = use_parse_context ? "ref input" : "input";
 
   printer->Print(

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

@@ -38,7 +38,6 @@
 #include <string>
 
 #include "google/protobuf/io/printer.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/java/context.h"
 #include "google/protobuf/compiler/java/doc_comment.h"
@@ -104,7 +103,7 @@ void EnumGenerator::Generate(io::Printer* printer) {
   }
 
   for (int i = 0; i < canonical_values_.size(); i++) {
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["name"] = canonical_values_[i]->name();
     vars["index"] = absl::StrCat(canonical_values_[i]->index());
     vars["number"] = absl::StrCat(canonical_values_[i]->number());
@@ -136,7 +135,7 @@ void EnumGenerator::Generate(io::Printer* printer) {
   // -----------------------------------------------------------------
 
   for (int i = 0; i < aliases_.size(); i++) {
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["classname"] = descriptor_->name();
     vars["name"] = aliases_[i].value->name();
     vars["canonical_name"] = aliases_[i].canonical_value->name();
@@ -147,7 +146,7 @@ void EnumGenerator::Generate(io::Printer* printer) {
   }
 
   for (int i = 0; i < descriptor_->value_count(); i++) {
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["name"] = descriptor_->value(i)->name();
     vars["number"] = absl::StrCat(descriptor_->value(i)->number());
     vars["{"] = "";

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

@@ -42,7 +42,6 @@
 #include "google/protobuf/stubs/common.h"
 #include "google/protobuf/io/printer.h"
 #include "google/protobuf/wire_format.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/java/context.h"
 #include "google/protobuf/compiler/java/doc_comment.h"
@@ -62,7 +61,7 @@ namespace {
 void SetEnumVariables(const FieldDescriptor* descriptor, int messageBitIndex,
                       int builderBitIndex, const FieldGeneratorInfo* info,
                       ClassNameResolver* name_resolver,
-                      absl::flat_hash_map<std::string, std::string>* variables,
+                      std::map<std::string, std::string>* variables,
                       Context* context) {
   SetCommonFieldVariables(descriptor, info, variables);
 

src/google/protobuf/compiler/java/enum_field.h

@@ -38,7 +38,6 @@
 #include <map>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/java/field.h"
 
 namespace google {
@@ -91,7 +90,7 @@ class ImmutableEnumFieldGenerator : public ImmutableFieldGenerator {
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
 };
 
@@ -154,7 +153,7 @@ class RepeatedImmutableEnumFieldGenerator : public ImmutableFieldGenerator {
 
  private:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
 };
 

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

@@ -42,9 +42,7 @@
 #include "google/protobuf/stubs/common.h"
 #include "google/protobuf/io/printer.h"
 #include "google/protobuf/wire_format.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
 #include "google/protobuf/compiler/java/context.h"
 #include "google/protobuf/compiler/java/doc_comment.h"
 #include "google/protobuf/compiler/java/helpers.h"
@@ -70,13 +68,13 @@ bool EnableExperimentalRuntimeForLite() {
 void SetEnumVariables(const FieldDescriptor* descriptor, int messageBitIndex,
                       int builderBitIndex, const FieldGeneratorInfo* info,
                       ClassNameResolver* name_resolver,
-                      absl::flat_hash_map<std::string, std::string>* variables,
+                      std::map<std::string, std::string>* variables,
                       Context* context) {
   SetCommonFieldVariables(descriptor, info, variables);
 
   (*variables)["type"] =
       name_resolver->GetImmutableClassName(descriptor->enum_type());
-  variables->emplace("kt_type", EscapeKotlinKeywords((*variables)["type"]));
+  (*variables)["kt_type"] = EscapeKotlinKeywords((*variables)["type"]);
   (*variables)["mutable_type"] =
       name_resolver->GetMutableClassName(descriptor->enum_type());
   (*variables)["default"] =
@@ -91,12 +89,11 @@ void SetEnumVariables(const FieldDescriptor* descriptor, int messageBitIndex,
   // by the proto compiler
   (*variables)["deprecation"] =
       descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
-  variables->emplace(
+  (*variables)["kt_deprecation"] =
-      "kt_deprecation",
       descriptor->options().deprecated()
-          ? absl::StrCat("@kotlin.Deprecated(message = \"Field ",
+          ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] +
-                         (*variables)["name"], " is deprecated\") ")
+                " is deprecated\") "
-          : "");
+          : "";
   (*variables)["required"] = descriptor->is_required() ? "true" : "false";
 
   if (HasHasbit(descriptor)) {
@@ -120,9 +117,9 @@ void SetEnumVariables(const FieldDescriptor* descriptor, int messageBitIndex,
     (*variables)["set_has_field_bit_message"] = "";
     (*variables)["clear_has_field_bit_message"] = "";
 
-    variables->emplace("is_field_present_message",
+    (*variables)["is_field_present_message"] =
-                       absl::StrCat((*variables)["name"], "_ != ",
+        (*variables)["name"] + "_ != " + (*variables)["default"] +
-                                    (*variables)["default"], ".getNumber()"));
+        ".getNumber()";
   }
 
   (*variables)["get_has_field_bit_from_local"] =
@@ -131,10 +128,9 @@ void SetEnumVariables(const FieldDescriptor* descriptor, int messageBitIndex,
       GenerateSetBitToLocal(messageBitIndex);
 
   if (SupportUnknownEnumValue(descriptor->file())) {
-    variables->emplace("unknown",
+    (*variables)["unknown"] = (*variables)["type"] + ".UNRECOGNIZED";
-                       absl::StrCat((*variables)["type"], ".UNRECOGNIZED"));
   } else {
-    variables->emplace("unknown", (*variables)["default"]);
+    (*variables)["unknown"] = (*variables)["default"];
   }
 
   // We use `x.getClass()` as a null check because it generates less bytecode

src/google/protobuf/compiler/java/enum_field_lite.h

@@ -39,7 +39,6 @@
 #include <map>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/java/field.h"
 
 namespace google {
@@ -84,7 +83,7 @@ class ImmutableEnumFieldLiteGenerator : public ImmutableFieldLiteGenerator {
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   const int messageBitIndex_;
   Context* context_;
   ClassNameResolver* name_resolver_;
@@ -132,7 +131,7 @@ class RepeatedImmutableEnumFieldLiteGenerator
 
  private:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   Context* context_;
   ClassNameResolver* name_resolver_;
 };

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

@@ -38,7 +38,6 @@
 #include <string>
 
 #include "google/protobuf/io/printer.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/java/context.h"
 #include "google/protobuf/compiler/java/doc_comment.h"
@@ -87,7 +86,7 @@ void EnumLiteGenerator::Generate(io::Printer* printer) {
   printer->Indent();
 
   for (int i = 0; i < canonical_values_.size(); i++) {
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["name"] = canonical_values_[i]->name();
     vars["number"] = absl::StrCat(canonical_values_[i]->number());
     WriteEnumValueDocComment(printer, canonical_values_[i]);
@@ -110,7 +109,7 @@ void EnumLiteGenerator::Generate(io::Printer* printer) {
   // -----------------------------------------------------------------
 
   for (int i = 0; i < aliases_.size(); i++) {
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["classname"] = descriptor_->name();
     vars["name"] = aliases_[i].value->name();
     vars["canonical_name"] = aliases_[i].canonical_value->name();
@@ -121,7 +120,7 @@ void EnumLiteGenerator::Generate(io::Printer* printer) {
   }
 
   for (int i = 0; i < descriptor_->value_count(); i++) {
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["name"] = descriptor_->value(i)->name();
     vars["number"] = absl::StrCat(descriptor_->value(i)->number());
     vars["{"] = "";

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

@@ -35,7 +35,6 @@
 #include "google/protobuf/compiler/java/extension.h"
 
 #include "google/protobuf/io/printer.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/java/context.h"
 #include "google/protobuf/compiler/java/doc_comment.h"
@@ -69,9 +68,8 @@ ImmutableExtensionGenerator::~ImmutableExtensionGenerator() {}
 void ExtensionGenerator::InitTemplateVars(
     const FieldDescriptor* descriptor, const std::string& scope, bool immutable,
     ClassNameResolver* name_resolver,
-    absl::flat_hash_map<std::string, std::string>* vars_pointer,
+    std::map<std::string, std::string>* vars_pointer, Context* context) {
-    Context* context) {
+  std::map<std::string, std::string>& vars = *vars_pointer;
-  absl::flat_hash_map<std::string, std::string>& vars = *vars_pointer;
   vars["scope"] = scope;
   vars["name"] = UnderscoresToCamelCaseCheckReserved(descriptor);
   vars["containing_type"] =
@@ -118,7 +116,7 @@ void ExtensionGenerator::InitTemplateVars(
 }
 
 void ImmutableExtensionGenerator::Generate(io::Printer* printer) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   const bool kUseImmutableNames = true;
   InitTemplateVars(descriptor_, scope_, kUseImmutableNames, name_resolver_,
                    &vars, context_);

src/google/protobuf/compiler/java/extension.h

@@ -38,7 +38,6 @@
 #include <map>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/port.h"
 
 namespace google {
@@ -82,11 +81,11 @@ class ExtensionGenerator {
   virtual int GenerateRegistrationCode(io::Printer* printer) = 0;
 
  protected:
-  static void InitTemplateVars(
+  static void InitTemplateVars(const FieldDescriptor* descriptor,
-      const FieldDescriptor* descriptor, const std::string& scope,
+                               const std::string& scope, bool immutable,
-      bool immutable, ClassNameResolver* name_resolver,
+                               ClassNameResolver* name_resolver,
-      absl::flat_hash_map<std::string, std::string>* vars_pointer,
+                               std::map<std::string, std::string>* vars_pointer,
-      Context* context);
+                               Context* context);
 };
 
 class ImmutableExtensionGenerator : public ExtensionGenerator {

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

@@ -31,7 +31,6 @@
 #include "google/protobuf/compiler/java/extension_lite.h"
 
 #include "google/protobuf/io/printer.h"
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/java/context.h"
 #include "google/protobuf/compiler/java/doc_comment.h"
 #include "google/protobuf/compiler/java/helpers.h"
@@ -61,7 +60,7 @@ ImmutableExtensionLiteGenerator::ImmutableExtensionLiteGenerator(
 ImmutableExtensionLiteGenerator::~ImmutableExtensionLiteGenerator() {}
 
 void ImmutableExtensionLiteGenerator::Generate(io::Printer* printer) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   const bool kUseImmutableNames = true;
   InitTemplateVars(descriptor_, scope_, kUseImmutableNames, name_resolver_,
                    &vars, context_);

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

@@ -39,7 +39,6 @@
 #include "google/protobuf/stubs/logging.h"
 #include "google/protobuf/stubs/common.h"
 #include "google/protobuf/io/printer.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/substitute.h"
 #include "google/protobuf/compiler/java/context.h"
@@ -242,9 +241,9 @@ template <>
 FieldGeneratorMap<ImmutableFieldLiteGenerator>::~FieldGeneratorMap() {}
 
 
-void SetCommonFieldVariables(
+void SetCommonFieldVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, const FieldGeneratorInfo* info,
+                             const FieldGeneratorInfo* info,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+                             std::map<std::string, std::string>* variables) {
   (*variables)["field_name"] = descriptor->name();
   (*variables)["name"] = info->name;
   (*variables)["classname"] = descriptor->containing_type()->name();
@@ -274,16 +273,15 @@ void SetCommonFieldVariables(
     (*variables)["annotation_field_type"] =
         std::string(FieldTypeName(descriptor->type())) + "_LIST";
     if (descriptor->is_packed()) {
-      variables->emplace(
+      (*variables)["annotation_field_type"] =
-          "annotation_field_type",
+          (*variables)["annotation_field_type"] + "_PACKED";
-          absl::StrCat((*variables)["annotation_field_type"], "_PACKED"));
     }
   }
 }
 
-void SetCommonOneofVariables(
+void SetCommonOneofVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, const OneofGeneratorInfo* info,
+                             const OneofGeneratorInfo* info,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+                             std::map<std::string, std::string>* variables) {
   (*variables)["oneof_name"] = info->name;
   (*variables)["oneof_capitalized_name"] = info->capitalized_name;
   (*variables)["oneof_index"] =
@@ -296,10 +294,9 @@ void SetCommonOneofVariables(
       info->name + "Case_ == " + absl::StrCat(descriptor->number());
 }
 
-void PrintExtraFieldInfo(
+void PrintExtraFieldInfo(const std::map<std::string, std::string>& variables,
-    const absl::flat_hash_map<std::string, std::string>& variables,
+                         io::Printer* printer) {
-    io::Printer* printer) {
+  const std::map<std::string, std::string>::const_iterator it =
-  const absl::flat_hash_map<std::string, std::string>::const_iterator it =
       variables.find("disambiguated_reason");
   if (it != variables.end() && !it->second.empty()) {
     printer->Print(

src/google/protobuf/compiler/java/field.h

@@ -43,7 +43,6 @@
 #include "google/protobuf/stubs/logging.h"
 #include "google/protobuf/stubs/common.h"
 #include "google/protobuf/descriptor.h"
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/port.h"
 
 namespace google {
@@ -170,19 +169,18 @@ struct OneofGeneratorInfo {
 };
 
 // Set some common variables used in variable FieldGenerators.
-void SetCommonFieldVariables(
+void SetCommonFieldVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, const FieldGeneratorInfo* info,
+                             const FieldGeneratorInfo* info,
-    absl::flat_hash_map<std::string, std::string>* variables);
+                             std::map<std::string, std::string>* variables);
 
 // Set some common oneof variables used in OneofFieldGenerators.
-void SetCommonOneofVariables(
+void SetCommonOneofVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, const OneofGeneratorInfo* info,
+                             const OneofGeneratorInfo* info,
-    absl::flat_hash_map<std::string, std::string>* variables);
+                             std::map<std::string, std::string>* variables);
 
 // Print useful comments before a field's accessors.
-void PrintExtraFieldInfo(
+void PrintExtraFieldInfo(const std::map<std::string, std::string>& variables,
-    const absl::flat_hash_map<std::string, std::string>& variables,
+                         io::Printer* printer);
-    io::Printer* printer);
 
 }  // namespace java
 }  // namespace compiler

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

@@ -84,10 +84,11 @@ void PrintGeneratedAnnotation(io::Printer* printer, char delimiter,
   printer->Print(ptemplate.c_str(), "annotation_file", annotation_file);
 }
 
-void PrintEnumVerifierLogic(
+void PrintEnumVerifierLogic(io::Printer* printer,
-    io::Printer* printer, const FieldDescriptor* descriptor,
+                            const FieldDescriptor* descriptor,
-    const absl::flat_hash_map<std::string, std::string>& variables,
+                            const std::map<std::string, std::string>& variables,
-    const char* var_name, const char* terminating_string, bool enforce_lite) {
+                            const char* var_name,
+                            const char* terminating_string, bool enforce_lite) {
   std::string enum_verifier_string =
       enforce_lite ? absl::StrCat(var_name, ".internalGetVerifier()")
                    : absl::StrCat(

src/google/protobuf/compiler/java/helpers.h

@@ -74,10 +74,11 @@ void PrintGeneratedAnnotation(io::Printer* printer, char delimiter = '$',
 
 // If a GeneratedMessageLite contains non-lite enums, then its verifier
 // must be instantiated inline, rather than retrieved from the enum class.
-void PrintEnumVerifierLogic(
+void PrintEnumVerifierLogic(io::Printer* printer,
-    io::Printer* printer, const FieldDescriptor* descriptor,
+                            const FieldDescriptor* descriptor,
-    const absl::flat_hash_map<std::string, std::string>& variables,
+                            const std::map<std::string, std::string>& variables,
-    const char* var_name, const char* terminating_string, bool enforce_lite);
+                            const char* var_name,
+                            const char* terminating_string, bool enforce_lite);
 
 // Converts a name to camel-case. If cap_first_letter is true, capitalize the
 // first letter.

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

@@ -31,7 +31,6 @@
 #include "google/protobuf/compiler/java/map_field.h"
 
 #include "google/protobuf/io/printer.h"
-#include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/java/context.h"
 #include "google/protobuf/compiler/java/doc_comment.h"
 #include "google/protobuf/compiler/java/helpers.h"
@@ -89,10 +88,10 @@ std::string WireType(const FieldDescriptor* field) {
          std::string(FieldTypeName(field->type()));
 }
 
-void SetMessageVariables(
+void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex,
-    const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+                         int builderBitIndex, const FieldGeneratorInfo* info,
-    const FieldGeneratorInfo* info, Context* context,
+                         Context* context,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+                         std::map<std::string, std::string>* variables) {
   SetCommonFieldVariables(descriptor, info, variables);
   ClassNameResolver* name_resolver = context->GetNameResolver();
 
@@ -134,8 +133,8 @@ void SetMessageVariables(
   if (valueJavaType == JAVATYPE_ENUM) {
     // We store enums as Integers internally.
     (*variables)["value_type"] = "int";
-    variables->emplace("value_type_pass_through_nullness",
+    (*variables)["value_type_pass_through_nullness"] =
-                       (*variables)["value_type"]);
+        (*variables)["value_type"];
     (*variables)["boxed_value_type"] = "java.lang.Integer";
     (*variables)["value_wire_type"] = WireType(value);
     (*variables)["value_default_value"] =
@@ -144,15 +143,13 @@ void SetMessageVariables(
 
     (*variables)["value_enum_type"] = TypeName(value, name_resolver, false);
 
-    variables->emplace(
+    (*variables)["value_enum_type_pass_through_nullness"] =
-        "value_enum_type_pass_through_nullness",
+        pass_through_nullness + (*variables)["value_enum_type"];
-        absl::StrCat(pass_through_nullness, (*variables)["value_enum_type"]));
 
     if (SupportUnknownEnumValue(descriptor->file())) {
       // Map unknown values to a special UNRECOGNIZED value if supported.
-      variables->emplace(
+      (*variables)["unrecognized_value"] =
-          "unrecognized_value",
+          (*variables)["value_enum_type"] + ".UNRECOGNIZED";
-          absl::StrCat((*variables)["value_enum_type"], ".UNRECOGNIZED"));
     } else {
       // Map unknown values to the default value if we don't have UNRECOGNIZED.
       (*variables)["unrecognized_value"] =
@@ -161,36 +158,31 @@ void SetMessageVariables(
   } else {
     (*variables)["value_type"] = TypeName(value, name_resolver, false);
 
-    variables->emplace(
+    (*variables)["value_type_pass_through_nullness"] =
-        "value_type_pass_through_nullness",
+        (IsReferenceType(valueJavaType) ? pass_through_nullness : "") +
-        absl::StrCat(
+        (*variables)["value_type"];
-            (IsReferenceType(valueJavaType) ? pass_through_nullness : ""),
-            (*variables)["value_type"]));
 
     (*variables)["boxed_value_type"] = TypeName(value, name_resolver, true);
     (*variables)["value_wire_type"] = WireType(value);
     (*variables)["value_default_value"] =
         DefaultValue(value, true, name_resolver, context->options());
   }
-  variables->emplace("type_parameters",
+  (*variables)["type_parameters"] =
-                     absl::StrCat((*variables)["boxed_key_type"], ", ",
+      (*variables)["boxed_key_type"] + ", " + (*variables)["boxed_value_type"];
-                                  (*variables)["boxed_value_type"]));
   // TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
   // by the proto compiler
   (*variables)["deprecation"] =
       descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
-  variables->emplace(
+  (*variables)["kt_deprecation"] =
-      "kt_deprecation",
       descriptor->options().deprecated()
-          ? absl::StrCat("@kotlin.Deprecated(message = \"Field ",
+          ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] +
-                         (*variables)["name"], " is deprecated\") ")
+                " is deprecated\") "
-          : "");
+          : "";
   (*variables)["on_changed"] = "onChanged();";
 
-  variables->emplace("default_entry",
+  (*variables)["default_entry"] =
-                     absl::StrCat((*variables)["capitalized_name"],
+      (*variables)["capitalized_name"] + "DefaultEntryHolder.defaultEntry";
-                                  "DefaultEntryHolder.defaultEntry"));
+  (*variables)["map_field_parameter"] = (*variables)["default_entry"];
-  variables->emplace("map_field_parameter", (*variables)["default_entry"]);
   (*variables)["descriptor"] =
       name_resolver->GetImmutableClassName(descriptor->file()) + ".internal_" +
       UniqueFileScopeIdentifier(descriptor->message_type()) + "_descriptor, ";

src/google/protobuf/compiler/java/map_field.h

@@ -68,7 +68,7 @@ class ImmutableMapFieldGenerator : public ImmutableFieldGenerator {
 
  private:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
   Context* context_;
   void GenerateMapGetters(io::Printer* printer) const;

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

@@ -90,10 +90,10 @@ std::string WireType(const FieldDescriptor* field) {
          std::string(FieldTypeName(field->type()));
 }
 
-void SetMessageVariables(
+void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex,
-    const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+                         int builderBitIndex, const FieldGeneratorInfo* info,
-    const FieldGeneratorInfo* info, Context* context,
+                         Context* context,
-    absl::flat_hash_map<std::string, std::string>* variables) {
+                         std::map<std::string, std::string>* variables) {
   SetCommonFieldVariables(descriptor, info, variables);
 
   ClassNameResolver* name_resolver = context->GetNameResolver();

src/google/protobuf/compiler/java/map_field_lite.h

@@ -61,7 +61,7 @@ class ImmutableMapFieldLiteGenerator : public ImmutableFieldLiteGenerator {
 
  private:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   Context* context_;
   ClassNameResolver* name_resolver_;
 };

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

@@ -115,7 +115,7 @@ void ImmutableMessageGenerator::GenerateStaticVariables(
   // the outermost class in the file.  This way, they will be initialized in
   // a deterministic order.
 
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["identifier"] = UniqueFileScopeIdentifier(descriptor_);
   vars["index"] = absl::StrCat(descriptor_->index());
   vars["classname"] = name_resolver_->GetImmutableClassName(descriptor_);
@@ -159,7 +159,7 @@ void ImmutableMessageGenerator::GenerateStaticVariables(
 int ImmutableMessageGenerator::GenerateStaticVariableInitializers(
     io::Printer* printer) {
   int bytecode_estimate = 0;
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["identifier"] = UniqueFileScopeIdentifier(descriptor_);
   vars["index"] = absl::StrCat(descriptor_->index());
   vars["classname"] = name_resolver_->GetImmutableClassName(descriptor_);
@@ -196,7 +196,7 @@ int ImmutableMessageGenerator::GenerateStaticVariableInitializers(
 
 void ImmutableMessageGenerator::GenerateFieldAccessorTable(
     io::Printer* printer, int* bytecode_estimate) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["identifier"] = UniqueFileScopeIdentifier(descriptor_);
   if (MultipleJavaFiles(descriptor_->file(), /* immutable = */ true)) {
     // We can only make these package-private since the classes that use them
@@ -314,7 +314,7 @@ void ImmutableMessageGenerator::GenerateInterface(io::Printer* printer) {
 void ImmutableMessageGenerator::Generate(io::Printer* printer) {
   bool is_own_file = IsOwnFile(descriptor_, /* immutable = */ true);
 
-  absl::flat_hash_map<std::string, std::string> variables;
+  std::map<std::string, std::string> variables;
   variables["static"] = is_own_file ? "" : "static ";
   variables["classname"] = descriptor_->name();
   variables["extra_interfaces"] = ExtraMessageInterfaces(descriptor_);
@@ -426,7 +426,7 @@ void ImmutableMessageGenerator::Generate(io::Printer* printer) {
   }
 
   // oneof
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   for (auto oneof : oneofs_) {
     vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name;
     vars["oneof_capitalized_name"] =

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

@@ -126,7 +126,7 @@ void MessageBuilderGenerator::Generate(io::Printer* printer) {
   }
 
   // oneof
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   for (auto oneof : oneofs_) {
     vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name;
     vars["oneof_capitalized_name"] =

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

@@ -82,7 +82,7 @@ MessageBuilderLiteGenerator::~MessageBuilderLiteGenerator() {}
 
 void MessageBuilderLiteGenerator::Generate(io::Printer* printer) {
   WriteMessageDocComment(printer, descriptor_);
-  absl::flat_hash_map<std::string, std::string> vars = {
+  std::map<std::string, std::string> vars = {
       {"{", ""},
       {"}", ""},
       {"classname", name_resolver_->GetImmutableClassName(descriptor_)},

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

@@ -39,7 +39,6 @@
 
 #include "google/protobuf/io/printer.h"
 #include "google/protobuf/wire_format.h"
-#include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/java/context.h"
 #include "google/protobuf/compiler/java/doc_comment.h"
 #include "google/protobuf/compiler/java/helpers.h"
@@ -56,16 +55,16 @@ namespace java {
 
 namespace {
 
-void SetMessageVariables(
+void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex,
-    const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+                         int builderBitIndex, const FieldGeneratorInfo* info,
-    const FieldGeneratorInfo* info, ClassNameResolver* name_resolver,
+                         ClassNameResolver* name_resolver,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                         std::map<std::string, std::string>* variables,
-    Context* context) {
+                         Context* context) {
   SetCommonFieldVariables(descriptor, info, variables);
 
   (*variables)["type"] =
       name_resolver->GetImmutableClassName(descriptor->message_type());
-  variables->emplace("kt_type", EscapeKotlinKeywords((*variables)["type"]));
+  (*variables)["kt_type"] = EscapeKotlinKeywords((*variables)["type"]);
   (*variables)["mutable_type"] =
       name_resolver->GetMutableClassName(descriptor->message_type());
   (*variables)["group_or_message"] =
@@ -75,12 +74,11 @@ void SetMessageVariables(
   // by the proto compiler
   (*variables)["deprecation"] =
       descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
-  variables->emplace(
+  (*variables)["kt_deprecation"] =
-      "kt_deprecation",
       descriptor->options().deprecated()
-          ? absl::StrCat("@kotlin.Deprecated(message = \"Field ",
+          ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] +
-                         (*variables)["name"], " is deprecated\") ")
+                " is deprecated\") "
-          : "");
+          : "";
   (*variables)["on_changed"] = "onChanged();";
   (*variables)["ver"] = GeneratedCodeVersionSuffix();
   (*variables)["get_parser"] =
@@ -108,8 +106,8 @@ void SetMessageVariables(
     (*variables)["set_has_field_bit_builder"] = "";
     (*variables)["clear_has_field_bit_builder"] = "";
 
-    variables->emplace("is_field_present_message",
+    (*variables)["is_field_present_message"] =
-                       absl::StrCat((*variables)["name"], "_ != null"));
+        (*variables)["name"] + "_ != null";
   }
 
   // For repeated builders, one bit is used for whether the array is immutable.

src/google/protobuf/compiler/java/message_field.h

@@ -92,7 +92,7 @@ class ImmutableMessageFieldGenerator : public ImmutableFieldGenerator {
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
   Context* context_;
 
@@ -165,7 +165,7 @@ class RepeatedImmutableMessageFieldGenerator : public ImmutableFieldGenerator {
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
 
   void PrintNestedBuilderCondition(io::Printer* printer,

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

@@ -56,16 +56,16 @@ namespace java {
 
 namespace {
 
-void SetMessageVariables(
+void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex,
-    const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+                         int builderBitIndex, const FieldGeneratorInfo* info,
-    const FieldGeneratorInfo* info, ClassNameResolver* name_resolver,
+                         ClassNameResolver* name_resolver,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                         std::map<std::string, std::string>* variables,
-    Context* context) {
+                         Context* context) {
   SetCommonFieldVariables(descriptor, info, variables);
 
   (*variables)["type"] =
       name_resolver->GetImmutableClassName(descriptor->message_type());
-  variables->emplace("kt_type", EscapeKotlinKeywords((*variables)["type"]));
+  (*variables)["kt_type"] = EscapeKotlinKeywords((*variables)["type"]);
   (*variables)["mutable_type"] =
       name_resolver->GetMutableClassName(descriptor->message_type());
   (*variables)["group_or_message"] =
@@ -75,12 +75,11 @@ void SetMessageVariables(
   // by the proto compiler
   (*variables)["deprecation"] =
       descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
-  variables->emplace(
+  (*variables)["kt_deprecation"] =
-      "kt_deprecation",
       descriptor->options().deprecated()
-          ? absl::StrCat("@kotlin.Deprecated(message = \"Field ",
+          ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] +
-                         (*variables)["name"], " is deprecated\") ")
+                " is deprecated\") "
-          : "");
+          : "";
   (*variables)["required"] = descriptor->is_required() ? "true" : "false";
 
   if (HasHasbit(descriptor)) {
@@ -99,7 +98,7 @@ void SetMessageVariables(
     (*variables)["clear_has_field_bit_message"] = "";
 
     (*variables)["is_field_present_message"] =
-        absl::StrCat((*variables)["name"], "_ != null");
+        (*variables)["name"] + "_ != null";
   }
 
   (*variables)["get_has_field_bit_from_local"] =

src/google/protobuf/compiler/java/message_field_lite.h

@@ -83,7 +83,7 @@ class ImmutableMessageFieldLiteGenerator : public ImmutableFieldLiteGenerator {
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   const int messageBitIndex_;
   ClassNameResolver* name_resolver_;
   Context* context_;
@@ -136,7 +136,7 @@ class RepeatedImmutableMessageFieldLiteGenerator
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
   Context* context_;
 };

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

@@ -117,7 +117,7 @@ void ImmutableMessageLiteGenerator::GenerateInterface(io::Printer* printer) {
   MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
                                 /* immutable = */ true, "OrBuilder");
 
-  absl::flat_hash_map<std::string, std::string> variables = {
+  std::map<std::string, std::string> variables = {
       {"{", ""},
       {"}", ""},
       {"deprecation",
@@ -173,8 +173,7 @@ void ImmutableMessageLiteGenerator::GenerateInterface(io::Printer* printer) {
 void ImmutableMessageLiteGenerator::Generate(io::Printer* printer) {
   bool is_own_file = IsOwnFile(descriptor_, /* immutable = */ true);
 
-  absl::flat_hash_map<std::string, std::string> variables = {{"{", ""},
+  std::map<std::string, std::string> variables = {{"{", ""}, {"}", ""}};
-                                                             {"}", ""}};
   variables["static"] = is_own_file ? " " : " static ";
   variables["classname"] = descriptor_->name();
   variables["extra_interfaces"] = ExtraMessageInterfaces(descriptor_);
@@ -243,7 +242,7 @@ void ImmutableMessageLiteGenerator::Generate(io::Printer* printer) {
   }
 
   // oneof
-  absl::flat_hash_map<std::string, std::string> vars = {{"{", ""}, {"}", ""}};
+  std::map<std::string, std::string> vars = {{"{", ""}, {"}", ""}};
   for (auto oneof : oneofs_) {
     vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name;
     vars["oneof_capitalized_name"] =

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

@@ -57,55 +57,54 @@ using internal::WireFormat;
 
 namespace {
 
-void SetPrimitiveVariables(
+void SetPrimitiveVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+                           int messageBitIndex, int builderBitIndex,
-    const FieldGeneratorInfo* info, ClassNameResolver* name_resolver,
+                           const FieldGeneratorInfo* info,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                           ClassNameResolver* name_resolver,
-    Context* context) {
+                           std::map<std::string, std::string>* variables,
+                           Context* context) {
   SetCommonFieldVariables(descriptor, info, variables);
   JavaType javaType = GetJavaType(descriptor);
 
   (*variables)["type"] = PrimitiveTypeName(javaType);
   (*variables)["boxed_type"] = BoxedPrimitiveTypeName(javaType);
   (*variables)["kt_type"] = KotlinTypeName(javaType);
-  variables->emplace("field_type", (*variables)["type"]);
+  (*variables)["field_type"] = (*variables)["type"];
 
-  std::string name = (*variables)["name"];
   if (javaType == JAVATYPE_BOOLEAN || javaType == JAVATYPE_DOUBLE ||
       javaType == JAVATYPE_FLOAT || javaType == JAVATYPE_INT ||
       javaType == JAVATYPE_LONG) {
     std::string capitalized_type = UnderscoresToCamelCase(
         PrimitiveTypeName(javaType), /*cap_first_letter=*/true);
     (*variables)["field_list_type"] =
-        absl::StrCat("com.google.protobuf.Internal.", capitalized_type, "List");
+        "com.google.protobuf.Internal." + capitalized_type + "List";
-    (*variables)["empty_list"] =
+    (*variables)["empty_list"] = "empty" + capitalized_type + "List()";
-        absl::StrCat("empty", capitalized_type, "List()");
+    (*variables)["create_list"] = "new" + capitalized_type + "List()";
-    (*variables)["create_list"] =
-        absl::StrCat("new", capitalized_type, "List()");
     (*variables)["mutable_copy_list"] =
-        absl::StrCat("mutableCopy(", name, "_)");
+        "mutableCopy(" + (*variables)["name"] + "_)";
     (*variables)["name_make_immutable"] =
-        absl::StrCat(name, "_.makeImmutable()");
+        (*variables)["name"] + "_.makeImmutable()";
     (*variables)["repeated_get"] =
-        absl::StrCat(name, "_.get", capitalized_type);
+        (*variables)["name"] + "_.get" + capitalized_type;
     (*variables)["repeated_add"] =
-        absl::StrCat(name, "_.add", capitalized_type);
+        (*variables)["name"] + "_.add" + capitalized_type;
     (*variables)["repeated_set"] =
-        absl::StrCat(name, "_.set", capitalized_type);
+        (*variables)["name"] + "_.set" + capitalized_type;
   } else {
-    std::string boxed_type = (*variables)["boxed_type"];
     (*variables)["field_list_type"] =
-        absl::StrCat("java.util.List<", boxed_type, ">");
+        "java.util.List<" + (*variables)["boxed_type"] + ">";
     (*variables)["create_list"] =
-        absl::StrCat("new java.util.ArrayList<", boxed_type, ">()");
+        "new java.util.ArrayList<" + (*variables)["boxed_type"] + ">()";
-    (*variables)["mutable_copy_list"] =
+    (*variables)["mutable_copy_list"] = "new java.util.ArrayList<" +
-        absl::StrCat("new java.util.ArrayList<", boxed_type, ">(", name, "_)");
+                                        (*variables)["boxed_type"] + ">(" +
+                                        (*variables)["name"] + "_)";
     (*variables)["empty_list"] = "java.util.Collections.emptyList()";
-    (*variables)["name_make_immutable"] = absl::StrCat(
+    (*variables)["name_make_immutable"] =
-        name, "_ = java.util.Collections.unmodifiableList(", name, "_)");
+        (*variables)["name"] + "_ = java.util.Collections.unmodifiableList(" +
-    (*variables)["repeated_get"] = absl::StrCat(name, "_.get");
+        (*variables)["name"] + "_)";
-    (*variables)["repeated_add"] = absl::StrCat(name, "_.add");
+    (*variables)["repeated_get"] = (*variables)["name"] + "_.get";
-    (*variables)["repeated_set"] = absl::StrCat(name, "_.set");
+    (*variables)["repeated_add"] = (*variables)["name"] + "_.add";
+    (*variables)["repeated_set"] = (*variables)["name"] + "_.set";
   }
 
   (*variables)["default"] =
@@ -135,8 +134,8 @@ void SetPrimitiveVariables(
       descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
   (*variables)["kt_deprecation"] =
       descriptor->options().deprecated()
-          ? absl::StrCat("@kotlin.Deprecated(message = \"Field ", name,
+          ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] +
-                         " is deprecated\") ")
+                " is deprecated\") "
           : "";
   int fixed_size = FixedSize(GetType(descriptor));
   if (fixed_size != -1) {
@@ -166,20 +165,21 @@ void SetPrimitiveVariables(
     switch (descriptor->type()) {
       case FieldDescriptor::TYPE_BYTES:
         (*variables)["is_field_present_message"] =
-            absl::StrCat("!", name, "_.isEmpty()");
+            "!" + (*variables)["name"] + "_.isEmpty()";
         break;
       case FieldDescriptor::TYPE_FLOAT:
         (*variables)["is_field_present_message"] =
-            absl::StrCat("java.lang.Float.floatToRawIntBits(", name, "_) != 0");
+            "java.lang.Float.floatToRawIntBits(" + (*variables)["name"] +
+            "_) != 0";
         break;
       case FieldDescriptor::TYPE_DOUBLE:
-        (*variables)["is_field_present_message"] = absl::StrCat(
+        (*variables)["is_field_present_message"] =
-            "java.lang.Double.doubleToRawLongBits(", name, "_) != 0");
+            "java.lang.Double.doubleToRawLongBits(" + (*variables)["name"] +
+            "_) != 0";
         break;
       default:
-        variables->emplace(
+        (*variables)["is_field_present_message"] =
-            "is_field_present_message",
+            (*variables)["name"] + "_ != " + (*variables)["default"];
-            absl::StrCat(name, "_ != ", (*variables)["default"]));
         break;
     }
   }

src/google/protobuf/compiler/java/primitive_field.h

@@ -92,7 +92,7 @@ class ImmutablePrimitiveFieldGenerator : public ImmutableFieldGenerator {
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
 };
 
@@ -155,7 +155,7 @@ class RepeatedImmutablePrimitiveFieldGenerator
 
  private:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
 };
 

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

@@ -66,17 +66,18 @@ bool EnableExperimentalRuntimeForLite() {
 #endif  // !PROTOBUF_EXPERIMENT
 }
 
-void SetPrimitiveVariables(
+void SetPrimitiveVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+                           int messageBitIndex, int builderBitIndex,
-    const FieldGeneratorInfo* info, ClassNameResolver* name_resolver,
+                           const FieldGeneratorInfo* info,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                           ClassNameResolver* name_resolver,
-    Context* context) {
+                           std::map<std::string, std::string>* variables,
+                           Context* context) {
   SetCommonFieldVariables(descriptor, info, variables);
   JavaType javaType = GetJavaType(descriptor);
   (*variables)["type"] = PrimitiveTypeName(javaType);
   (*variables)["boxed_type"] = BoxedPrimitiveTypeName(javaType);
   (*variables)["kt_type"] = KotlinTypeName(javaType);
-  variables->emplace("field_type", (*variables)["type"]);
+  (*variables)["field_type"] = (*variables)["type"];
   (*variables)["default"] =
       ImmutableDefaultValue(descriptor, name_resolver, context->options());
   (*variables)["capitalized_type"] = GetCapitalizedType(
@@ -89,47 +90,43 @@ void SetPrimitiveVariables(
 
   std::string capitalized_type = UnderscoresToCamelCase(
       PrimitiveTypeName(javaType), true /* cap_next_letter */);
-  std::string name = (*variables)["name"];
   switch (javaType) {
     case JAVATYPE_INT:
     case JAVATYPE_LONG:
     case JAVATYPE_FLOAT:
     case JAVATYPE_DOUBLE:
     case JAVATYPE_BOOLEAN:
-      (*variables)["field_list_type"] = absl::StrCat(
+      (*variables)["field_list_type"] =
-          "com.google.protobuf.Internal.", capitalized_type, "List");
+          "com.google.protobuf.Internal." + capitalized_type + "List";
-      (*variables)["empty_list"] =
+      (*variables)["empty_list"] = "empty" + capitalized_type + "List()";
-          absl::StrCat("empty", capitalized_type, "List()");
       (*variables)["make_name_unmodifiable"] =
-          absl::StrCat(name, "_.makeImmutable()");
+          (*variables)["name"] + "_.makeImmutable()";
       (*variables)["repeated_get"] =
-          absl::StrCat(name, "_.get", capitalized_type);
+          (*variables)["name"] + "_.get" + capitalized_type;
       (*variables)["repeated_add"] =
-          absl::StrCat(name, "_.add", capitalized_type);
+          (*variables)["name"] + "_.add" + capitalized_type;
       (*variables)["repeated_set"] =
-          absl::StrCat(name, "_.set", capitalized_type);
+          (*variables)["name"] + "_.set" + capitalized_type;
       (*variables)["visit_type"] = capitalized_type;
-      (*variables)["visit_type_list"] =
+      (*variables)["visit_type_list"] = "visit" + capitalized_type + "List";
-          absl::StrCat("visit", capitalized_type, "List");
       break;
     default:
-      variables->emplace(
+      (*variables)["field_list_type"] =
-          "field_list_type",
+          "com.google.protobuf.Internal.ProtobufList<" +
-          absl::StrCat("com.google.protobuf.Internal.ProtobufList<",
+          (*variables)["boxed_type"] + ">";
-                       (*variables)["boxed_type"], ">"));
       (*variables)["empty_list"] = "emptyProtobufList()";
       (*variables)["make_name_unmodifiable"] =
-          absl::StrCat(name, "_.makeImmutable()");
+          (*variables)["name"] + "_.makeImmutable()";
-      (*variables)["repeated_get"] = absl::StrCat(name, "_.get");
+      (*variables)["repeated_get"] = (*variables)["name"] + "_.get";
-      (*variables)["repeated_add"] = absl::StrCat(name, "_.add");
+      (*variables)["repeated_add"] = (*variables)["name"] + "_.add";
-      (*variables)["repeated_set"] = absl::StrCat(name, "_.set");
+      (*variables)["repeated_set"] = (*variables)["name"] + "_.set";
       (*variables)["visit_type"] = "ByteString";
       (*variables)["visit_type_list"] = "visitList";
   }
 
   if (javaType == JAVATYPE_BYTES) {
     (*variables)["bytes_default"] =
-        absl::AsciiStrToUpper(name) + "_DEFAULT_VALUE";
+        absl::AsciiStrToUpper((*variables)["name"]) + "_DEFAULT_VALUE";
   }
 
   if (IsReferenceType(javaType)) {
@@ -146,8 +143,8 @@ void SetPrimitiveVariables(
       descriptor->options().deprecated() ? "@java.lang.Deprecated " : "";
   (*variables)["kt_deprecation"] =
       descriptor->options().deprecated()
-          ? absl::StrCat("@kotlin.Deprecated(message = \"Field ", name,
+          ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] +
-                         " is deprecated\") ")
+                " is deprecated\") "
           : "";
   int fixed_size = FixedSize(GetType(descriptor));
   if (fixed_size != -1) {
@@ -172,20 +169,21 @@ void SetPrimitiveVariables(
     switch (descriptor->type()) {
       case FieldDescriptor::TYPE_BYTES:
         (*variables)["is_field_present_message"] =
-            absl::StrCat("!", name, "_.isEmpty()");
+            "!" + (*variables)["name"] + "_.isEmpty()";
         break;
       case FieldDescriptor::TYPE_FLOAT:
         (*variables)["is_field_present_message"] =
-            absl::StrCat("java.lang.Float.floatToRawIntBits(", name, "_) != 0");
+            "java.lang.Float.floatToRawIntBits(" + (*variables)["name"] +
+            "_) != 0";
         break;
       case FieldDescriptor::TYPE_DOUBLE:
-        (*variables)["is_field_present_message"] = absl::StrCat(
+        (*variables)["is_field_present_message"] =
-            "java.lang.Double.doubleToRawLongBits(", name, "_) != 0");
+            "java.lang.Double.doubleToRawLongBits(" + (*variables)["name"] +
+            "_) != 0";
         break;
       default:
-        variables->emplace(
+        (*variables)["is_field_present_message"] =
-            "is_field_present_message",
+            (*variables)["name"] + "_ != " + (*variables)["default"];
-            absl::StrCat(name, "_ != " + (*variables)["default"]));
         break;
     }
   }
@@ -195,8 +193,7 @@ void SetPrimitiveVariables(
   (*variables)["set_has_field_bit_to_local"] =
       GenerateSetBitToLocal(messageBitIndex);
   // Annotations often use { and } variables to denote ranges.
-  (*variables)["{"] = "";
+  (*variables)["{"] = (*variables)["}"] = "";
-  (*variables)["}"] = "";
 }
 
 }  // namespace

src/google/protobuf/compiler/java/primitive_field_lite.h

@@ -83,7 +83,7 @@ class ImmutablePrimitiveFieldLiteGenerator
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   const int messageBitIndex_;
   Context* context_;
   ClassNameResolver* name_resolver_;
@@ -133,7 +133,7 @@ class RepeatedImmutablePrimitiveFieldLiteGenerator
 
  private:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   Context* context_;
   ClassNameResolver* name_resolver_;
 };

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

@@ -215,7 +215,7 @@ void ImmutableServiceGenerator::GenerateCallMethod(io::Printer* printer) {
 
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["index"] = absl::StrCat(i);
     vars["method"] = UnderscoresToCamelCase(method);
     vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
@@ -262,7 +262,7 @@ void ImmutableServiceGenerator::GenerateCallBlockingMethod(
 
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["index"] = absl::StrCat(i);
     vars["method"] = UnderscoresToCamelCase(method);
     vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
@@ -307,7 +307,7 @@ void ImmutableServiceGenerator::GenerateGetPrototype(RequestOrResponse which,
 
   for (int i = 0; i < descriptor_->method_count(); i++) {
     const MethodDescriptor* method = descriptor_->method(i);
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["index"] = absl::StrCat(i);
     vars["type"] =
         (which == REQUEST)
@@ -362,7 +362,7 @@ void ImmutableServiceGenerator::GenerateStub(io::Printer* printer) {
     printer->Print(" {\n");
     printer->Indent();
 
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["index"] = absl::StrCat(i);
     vars["output"] = GetOutput(method);
     printer->Print(vars,
@@ -426,7 +426,7 @@ void ImmutableServiceGenerator::GenerateBlockingStub(io::Printer* printer) {
     printer->Print(" {\n");
     printer->Indent();
 
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["index"] = absl::StrCat(i);
     vars["output"] = GetOutput(method);
     printer->Print(vars,
@@ -449,7 +449,7 @@ void ImmutableServiceGenerator::GenerateBlockingStub(io::Printer* printer) {
 void ImmutableServiceGenerator::GenerateMethodSignature(
     io::Printer* printer, const MethodDescriptor* method,
     IsAbstract is_abstract) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["name"] = UnderscoresToCamelCase(method);
   vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
   vars["output"] = GetOutput(method);
@@ -463,7 +463,7 @@ void ImmutableServiceGenerator::GenerateMethodSignature(
 
 void ImmutableServiceGenerator::GenerateBlockingMethodSignature(
     io::Printer* printer, const MethodDescriptor* method) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["method"] = UnderscoresToCamelCase(method);
   vars["input"] = name_resolver_->GetImmutableClassName(method->input_type());
   vars["output"] = GetOutput(method);

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

@@ -59,11 +59,12 @@ using internal::WireFormatLite;
 
 namespace {
 
-void SetPrimitiveVariables(
+void SetPrimitiveVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+                           int messageBitIndex, int builderBitIndex,
-    const FieldGeneratorInfo* info, ClassNameResolver* name_resolver,
+                           const FieldGeneratorInfo* info,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                           ClassNameResolver* name_resolver,
-    Context* context) {
+                           std::map<std::string, std::string>* variables,
+                           Context* context) {
   SetCommonFieldVariables(descriptor, info, variables);
 
   (*variables)["empty_list"] = "com.google.protobuf.LazyStringArrayList.EMPTY";

src/google/protobuf/compiler/java/string_field.h

@@ -91,7 +91,7 @@ class ImmutableStringFieldGenerator : public ImmutableFieldGenerator {
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
 };
 
@@ -152,7 +152,7 @@ class RepeatedImmutableStringFieldGenerator : public ImmutableFieldGenerator {
 
  private:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
 };
 

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

@@ -59,11 +59,12 @@ using internal::WireFormatLite;
 
 namespace {
 
-void SetPrimitiveVariables(
+void SetPrimitiveVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex,
+                           int messageBitIndex, int builderBitIndex,
-    const FieldGeneratorInfo* info, ClassNameResolver* name_resolver,
+                           const FieldGeneratorInfo* info,
-    absl::flat_hash_map<std::string, std::string>* variables,
+                           ClassNameResolver* name_resolver,
-    Context* context) {
+                           std::map<std::string, std::string>* variables,
+                           Context* context) {
   SetCommonFieldVariables(descriptor, info, variables);
 
   (*variables)["empty_list"] =

src/google/protobuf/compiler/java/string_field_lite.h

@@ -84,7 +84,7 @@ class ImmutableStringFieldLiteGenerator : public ImmutableFieldLiteGenerator {
 
  protected:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   const int messageBitIndex_;
   ClassNameResolver* name_resolver_;
   Context* context_;
@@ -133,7 +133,7 @@ class RepeatedImmutableStringFieldLiteGenerator
 
  private:
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
   ClassNameResolver* name_resolver_;
   Context* context_;
 };

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

@@ -34,7 +34,6 @@
 #include <set>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/objectivec/helpers.h"
 #include "google/protobuf/compiler/objectivec/names.h"
 #include "google/protobuf/io/printer.h"
@@ -46,9 +45,8 @@ namespace objectivec {
 
 namespace {
 
-void SetEnumVariables(
+void SetEnumVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                      std::map<std::string, std::string>* variables) {
-    absl::flat_hash_map<std::string, std::string>* variables) {
   std::string type = EnumName(descriptor->enum_type());
   (*variables)["storage_type"] = type;
   // For non repeated fields, if it was defined in a different file, the

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

@@ -37,7 +37,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/objectivec/helpers.h"
 #include "google/protobuf/compiler/objectivec/names.h"
@@ -65,7 +64,7 @@ ExtensionGenerator::ExtensionGenerator(const std::string& root_class_name,
 }
 
 void ExtensionGenerator::GenerateMembersHeader(io::Printer* printer) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["method_name"] = method_name_;
   if (IsRetainedName(method_name_)) {
     vars["storage_attribute"] = " NS_RETURNS_NOT_RETAINED";
@@ -92,7 +91,7 @@ void ExtensionGenerator::GenerateMembersHeader(io::Printer* printer) {
 
 void ExtensionGenerator::GenerateStaticVariablesInitialization(
     io::Printer* printer) {
-  absl::flat_hash_map<std::string, std::string> vars;
+  std::map<std::string, std::string> vars;
   vars["root_class_and_method_name"] = root_class_and_method_name_;
   const std::string containing_type = ClassName(descriptor_->containing_type());
   vars["extended_type"] = ObjCClass(containing_type);

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

@@ -37,7 +37,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/objectivec/enum_field.h"
 #include "google/protobuf/compiler/objectivec/helpers.h"
@@ -54,9 +53,8 @@ namespace objectivec {
 
 namespace {
 
-void SetCommonFieldVariables(
+void SetCommonFieldVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                             std::map<std::string, std::string>* variables) {
-    absl::flat_hash_map<std::string, std::string>* variables) {
   std::string camel_case_name = FieldName(descriptor);
   std::string raw_field_name;
   if (descriptor->type() == FieldDescriptor::TYPE_GROUP) {

src/google/protobuf/compiler/objectivec/field.h

@@ -37,7 +37,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/match.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/io/printer.h"
@@ -105,7 +104,7 @@ class FieldGenerator {
   bool WantsHasProperty() const;
 
   const FieldDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
 };
 
 class SingleFieldGenerator : public FieldGenerator {

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

@@ -626,7 +626,7 @@ void FileGenerator::GenerateSource(io::Printer* printer) {
 
   // File descriptor only needed if there are messages to use it.
   if (!message_generators_.empty()) {
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["root_class_name"] = root_class_name_;
     vars["package"] = file_->package();
     vars["objc_prefix"] = FileClassPrefix(file_);

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

@@ -36,7 +36,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
 #include "google/protobuf/compiler/objectivec/line_consumer.h"
@@ -56,14 +55,13 @@ namespace {
 class ProtoFrameworkCollector : public LineConsumer {
  public:
   explicit ProtoFrameworkCollector(
-      absl::flat_hash_map<std::string, std::string>*
+      std::map<std::string, std::string>* inout_proto_file_to_framework_name)
-          inout_proto_file_to_framework_name)
       : map_(inout_proto_file_to_framework_name) {}
 
   bool ConsumeLine(absl::string_view line, std::string* out_error) override;
 
  private:
-  absl::flat_hash_map<std::string, std::string>* map_;
+  std::map<std::string, std::string>* map_;
 };
 
 bool ProtoFrameworkCollector::ConsumeLine(absl::string_view line,
@@ -90,7 +88,7 @@ bool ProtoFrameworkCollector::ConsumeLine(absl::string_view line,
     absl::string_view proto_file = absl::StripAsciiWhitespace(
         proto_file_list.substr(start, offset - start));
     if (!proto_file.empty()) {
-      absl::flat_hash_map<std::string, std::string>::iterator existing_entry =
+      std::map<std::string, std::string>::iterator existing_entry =
           map_->find(std::string(proto_file));
       if (existing_entry != map_->end()) {
         std::cerr << "warning: duplicate proto file reference, replacing "
@@ -149,7 +147,7 @@ void ImportWriter::AddFile(const FileDescriptor* file,
     ParseFrameworkMappings();
   }
 
-  absl::flat_hash_map<std::string, std::string>::iterator proto_lookup =
+  std::map<std::string, std::string>::iterator proto_lookup =
       proto_file_to_framework_name_.find(file->name());
   if (proto_lookup != proto_file_to_framework_name_.end()) {
     other_framework_imports_.push_back(

src/google/protobuf/compiler/objectivec/import_writer.h

@@ -35,7 +35,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/descriptor.pb.h"
 
@@ -69,7 +68,7 @@ class ImportWriter {
   const std::string named_framework_to_proto_path_mappings_path_;
   const std::string runtime_import_prefix_;
   const bool include_wkt_imports_;
-  absl::flat_hash_map<std::string, std::string> proto_file_to_framework_name_;
+  std::map<std::string, std::string> proto_file_to_framework_name_;
   bool need_to_parse_mapping_file_;
 
   std::vector<std::string> protobuf_imports_;

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

@@ -39,7 +39,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/objectivec/enum.h"
@@ -518,7 +517,7 @@ void MessageGenerator::GenerateSource(io::Printer* printer) {
       printer->Outdent();
     }
 
-    absl::flat_hash_map<std::string, std::string> vars;
+    std::map<std::string, std::string> vars;
     vars["classname"] = class_name_;
     vars["rootclassname"] = root_classname_;
     vars["fields"] = has_fields ? "fields" : "NULL";

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

@@ -34,7 +34,6 @@
 #include <set>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/compiler/objectivec/helpers.h"
 #include "google/protobuf/compiler/objectivec/names.h"
 
@@ -45,9 +44,8 @@ namespace objectivec {
 
 namespace {
 
-void SetMessageVariables(
+void SetMessageVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                         std::map<std::string, std::string>* variables) {
-    absl::flat_hash_map<std::string, std::string>* variables) {
   const std::string& message_type = ClassName(descriptor->message_type());
   const std::string& containing_class =
       ClassName(descriptor->containing_type());

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

@@ -41,7 +41,6 @@
 #include <vector>
 
 #include "google/protobuf/compiler/code_generator.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
@@ -84,16 +83,16 @@ class SimpleLineCollector : public LineConsumer {
 
 class PackageToPrefixesCollector : public LineConsumer {
  public:
-  PackageToPrefixesCollector(const std::string& usage,
+  PackageToPrefixesCollector(
-                             absl::flat_hash_map<std::string, std::string>*
+      const std::string& usage,
-                                 inout_package_to_prefix_map)
+      std::map<std::string, std::string>* inout_package_to_prefix_map)
       : usage_(usage), prefix_map_(inout_package_to_prefix_map) {}
 
   bool ConsumeLine(absl::string_view line, std::string* out_error) override;
 
  private:
   const std::string usage_;
-  absl::flat_hash_map<std::string, std::string>* prefix_map_;
+  std::map<std::string, std::string>* prefix_map_;
 };
 
 class PrefixModeStorage {
@@ -130,7 +129,7 @@ class PrefixModeStorage {
 
  private:
   bool use_package_name_;
-  absl::flat_hash_map<std::string, std::string> package_to_prefix_map_;
+  std::map<std::string, std::string> package_to_prefix_map_;
   std::string package_to_prefix_mappings_path_;
   std::string exception_path_;
   std::string forced_prefix_;
@@ -188,7 +187,7 @@ std::string PrefixModeStorage::prefix_from_proto_package_mappings(
   const std::string lookup_key =
       package.empty() ? no_package_prefix + file->name() : package;
 
-  absl::flat_hash_map<std::string, std::string>::const_iterator prefix_lookup =
+  std::map<std::string, std::string>::const_iterator prefix_lookup =
       package_to_prefix_map_.find(lookup_key);
 
   if (prefix_lookup != package_to_prefix_map_.end()) {
@@ -1022,10 +1021,9 @@ bool PackageToPrefixesCollector::ConsumeLine(absl::string_view line,
   return true;
 }
 
-bool LoadExpectedPackagePrefixes(
+bool LoadExpectedPackagePrefixes(const std::string& expected_prefixes_path,
-    const std::string& expected_prefixes_path,
+                                 std::map<std::string, std::string>* prefix_map,
-    absl::flat_hash_map<std::string, std::string>* prefix_map,
+                                 std::string* out_error) {
-    std::string* out_error) {
   if (expected_prefixes_path.empty()) {
     return true;
   }
@@ -1036,8 +1034,7 @@ bool LoadExpectedPackagePrefixes(
 
 bool ValidateObjCClassPrefix(
     const FileDescriptor* file, const std::string& expected_prefixes_path,
-    const absl::flat_hash_map<std::string, std::string>&
+    const std::map<std::string, std::string>& expected_package_prefixes,
-        expected_package_prefixes,
     bool prefixes_must_be_registered, bool require_prefixes,
     std::string* out_error) {
   // Reminder: An explicit prefix option of "" is valid in case the default
@@ -1060,7 +1057,7 @@ bool ValidateObjCClassPrefix(
 
   // Check: Error - See if there was an expected prefix for the package and
   // report if it doesn't match (wrong or missing).
-  absl::flat_hash_map<std::string, std::string>::const_iterator package_match =
+  std::map<std::string, std::string>::const_iterator package_match =
       expected_package_prefixes.find(lookup_key);
   if (package_match != expected_package_prefixes.end()) {
     // There was an entry, and...
@@ -1098,7 +1095,7 @@ bool ValidateObjCClassPrefix(
   if (!prefix.empty() && have_expected_prefix_file) {
     // For a non empty prefix, look for any other package that uses the prefix.
     std::string other_package_for_prefix;
-    for (absl::flat_hash_map<std::string, std::string>::const_iterator i =
+    for (std::map<std::string, std::string>::const_iterator i =
              expected_package_prefixes.begin();
          i != expected_package_prefixes.end(); ++i) {
       if (i->second == prefix) {
@@ -1216,7 +1213,7 @@ bool ValidateObjCClassPrefixes(const std::vector<const FileDescriptor*>& files,
   }
 
   // Load the expected package prefixes, if available, to validate against.
-  absl::flat_hash_map<std::string, std::string> expected_package_prefixes;
+  std::map<std::string, std::string> expected_package_prefixes;
   if (!LoadExpectedPackagePrefixes(validation_options.expected_prefixes_path,
                                    &expected_package_prefixes, out_error)) {
     return false;

src/google/protobuf/compiler/objectivec/oneof.h

@@ -36,7 +36,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/io/printer.h"
 
@@ -68,7 +67,7 @@ class OneofGenerator {
 
  private:
   const OneofDescriptor* descriptor_;
-  absl::flat_hash_map<std::string, std::string> variables_;
+  std::map<std::string, std::string> variables_;
 };
 
 }  // namespace objectivec

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

@@ -33,7 +33,6 @@
 #include <map>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "google/protobuf/compiler/objectivec/helpers.h"
 #include "google/protobuf/io/printer.h"
@@ -112,9 +111,8 @@ const char* PrimitiveArrayTypeName(const FieldDescriptor* descriptor) {
   return nullptr;
 }
 
-void SetPrimitiveVariables(
+void SetPrimitiveVariables(const FieldDescriptor* descriptor,
-    const FieldDescriptor* descriptor,
+                           std::map<std::string, std::string>* variables) {
-    absl::flat_hash_map<std::string, std::string>* variables) {
   std::string primitive_name = PrimitiveTypeName(descriptor);
   (*variables)["type"] = primitive_name;
   (*variables)["storage_type"] = primitive_name;

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

@@ -54,7 +54,6 @@
 
 #include "google/protobuf/stubs/logging.h"
 #include "google/protobuf/stubs/common.h"
-#include "absl/container/flat_hash_map.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
@@ -434,7 +433,7 @@ void Generator::PrintImports() const {
 
 // Prints the single file descriptor for this file.
 void Generator::PrintFileDescriptor() const {
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["name"] = file_->name();
   m["package"] = file_->package();
@@ -509,7 +508,7 @@ void Generator::PrintAllNestedEnumsInFile() const {
 // enum name to a Python EnumDescriptor object equivalent to
 // enum_descriptor.
 void Generator::PrintEnum(const EnumDescriptor& enum_descriptor) const {
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   std::string module_level_descriptor_name =
       ModuleLevelDescriptorName(enum_descriptor);
   m["descriptor_name"] = module_level_descriptor_name;
@@ -584,7 +583,7 @@ void Generator::PrintServices() const {
 
 void Generator::PrintServiceDescriptor(
     const ServiceDescriptor& descriptor) const {
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["service_name"] = ModuleLevelServiceDescriptorName(descriptor);
   m["name"] = descriptor.name();
   m["file"] = kDescriptorKey;
@@ -634,7 +633,7 @@ void Generator::PrintServiceStub(const ServiceDescriptor& descriptor) const {
 //
 // Mutually recursive with PrintNestedDescriptors().
 void Generator::PrintDescriptor(const Descriptor& message_descriptor) const {
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["name"] = message_descriptor.name();
   m["full_name"] = message_descriptor.full_name();
   m["file"] = kDescriptorKey;
@@ -785,7 +784,7 @@ void Generator::PrintMessage(const Descriptor& message_descriptor,
   to_register->push_back(qualified_name);
 
   PrintNestedMessages(message_descriptor, qualified_name, to_register);
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["descriptor_key"] = kDescriptorKey;
   m["descriptor_name"] = ModuleLevelDescriptorName(message_descriptor);
   printer_->Print(m, "'$descriptor_key$' : $descriptor_name$,\n");
@@ -840,7 +839,7 @@ void Generator::FixForeignFieldsInDescriptor(
     FixContainingTypeInDescriptor(enum_descriptor, &descriptor);
   }
   for (int i = 0; i < descriptor.oneof_decl_count(); ++i) {
-    absl::flat_hash_map<std::string, std::string> m;
+    std::map<std::string, std::string> m;
     const OneofDescriptor* oneof = descriptor.oneof_decl(i);
     m["descriptor_name"] = ModuleLevelDescriptorName(descriptor);
     m["oneof_name"] = oneof->name();
@@ -859,7 +858,7 @@ void Generator::FixForeignFieldsInDescriptor(
 }
 
 void Generator::AddMessageToFileDescriptor(const Descriptor& descriptor) const {
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["message_name"] = descriptor.name();
   m["message_descriptor_name"] = ModuleLevelDescriptorName(descriptor);
@@ -871,7 +870,7 @@ void Generator::AddMessageToFileDescriptor(const Descriptor& descriptor) const {
 
 void Generator::AddServiceToFileDescriptor(
     const ServiceDescriptor& descriptor) const {
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["service_name"] = descriptor.name();
   m["service_descriptor_name"] = ModuleLevelServiceDescriptorName(descriptor);
@@ -883,7 +882,7 @@ void Generator::AddServiceToFileDescriptor(
 
 void Generator::AddEnumToFileDescriptor(
     const EnumDescriptor& descriptor) const {
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["enum_name"] = descriptor.name();
   m["enum_descriptor_name"] = ModuleLevelDescriptorName(descriptor);
@@ -895,7 +894,7 @@ void Generator::AddEnumToFileDescriptor(
 
 void Generator::AddExtensionToFileDescriptor(
     const FieldDescriptor& descriptor) const {
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["descriptor_name"] = kDescriptorKey;
   m["field_name"] = descriptor.name();
   m["resolved_name"] = ResolveKeyword(descriptor.name());
@@ -919,7 +918,7 @@ void Generator::FixForeignFieldsInField(
     const std::string& python_dict_name) const {
   const std::string field_referencing_expression =
       FieldReferencingExpression(containing_type, field, python_dict_name);
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["field_ref"] = field_referencing_expression;
   const Descriptor* foreign_message_type = field.message_type();
   if (foreign_message_type) {
@@ -1015,7 +1014,7 @@ void Generator::FixForeignFieldsInExtension(
     const FieldDescriptor& extension_field) const {
   GOOGLE_CHECK(extension_field.is_extension());
 
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   // Confusingly, for FieldDescriptors that happen to be extensions,
   // containing_type() means "extended type."
   // On the other hand, extension_scope() will give us what we normally
@@ -1047,7 +1046,7 @@ void Generator::PrintEnumValueDescriptor(
   // More circular references.  ::sigh::
   std::string options_string;
   descriptor.options().SerializeToString(&options_string);
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["name"] = descriptor.name();
   m["index"] = absl::StrCat(descriptor.index());
   m["number"] = absl::StrCat(descriptor.number());
@@ -1075,7 +1074,7 @@ void Generator::PrintFieldDescriptor(const FieldDescriptor& field,
                                      bool is_extension) const {
   std::string options_string;
   field.options().SerializeToString(&options_string);
-  absl::flat_hash_map<std::string, std::string> m;
+  std::map<std::string, std::string> m;
   m["name"] = field.name();
   m["full_name"] = field.full_name();
   m["index"] = absl::StrCat(field.index());

src/google/protobuf/compiler/python/pyi_generator.h

@@ -39,7 +39,6 @@
 #include <set>
 #include <string>
 
-#include "absl/container/flat_hash_map.h"
 #include "absl/synchronization/mutex.h"
 #include "google/protobuf/compiler/code_generator.h"
 
@@ -107,7 +106,7 @@ class PROTOC_EXPORT PyiGenerator : public google::protobuf::compiler::CodeGenera
   mutable io::Printer* printer_;        // Set in Generate().  Under mutex_.
   // import_map will be a mapping from filename to module alias, e.g.
   // "google3/foo/bar.py" -> "_bar"
-  mutable absl::flat_hash_map<std::string, std::string> import_map_;
+  mutable std::map<std::string, std::string> import_map_;
 };
 
 }  // namespace python

src/google/protobuf/io/printer.h

@@ -40,6 +40,7 @@
 #include <cstddef>
 #include <functional>
 #include <initializer_list>
+#include <map>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -534,10 +535,10 @@ class PROTOBUF_EXPORT Printer {
   // Pushes a new variable lookup frame that stores `vars` by reference.
   //
   // Returns an RAII object that pops the lookup frame.
-  template <typename Map, typename StringType = absl::string_view>
+  template <typename Map>
   auto WithVars(const Map* vars) {
     var_lookups_.emplace_back([vars](absl::string_view var) -> LookupResult {
-      auto it = vars->find(StringType(var));
+      auto it = vars->find(std::string(var));
       if (it == vars->end()) {
         return absl::nullopt;
       }
@@ -553,12 +554,11 @@ class PROTOBUF_EXPORT Printer {
   //
   // Returns an RAII object that pops the lookup frame.
   template <typename Map = absl::flat_hash_map<std::string, std::string>,
-            typename StringType = absl::string_view,
             std::enable_if_t<!std::is_pointer<Map>::value, int> = 0>
   auto WithVars(Map&& vars) {
     var_lookups_.emplace_back([vars = std::forward<Map>(vars)](
                                   absl::string_view var) -> LookupResult {
-      auto it = vars.find(StringType(var));
+      auto it = vars.find(std::string(var));
       if (it == vars.end()) {
         return absl::nullopt;
       }
@@ -581,11 +581,11 @@ class PROTOBUF_EXPORT Printer {
   // Pushes a new annotation lookup frame that stores `vars` by reference.
   //
   // Returns an RAII object that pops the lookup frame.
-  template <typename Map, typename StringType = absl::string_view>
+  template <typename Map>
   auto WithAnnotations(const Map* vars) {
     annotation_lookups_.emplace_back(
         [vars](absl::string_view var) -> absl::optional<AnnotationRecord> {
-          auto it = vars->find(StringType(var));
+          auto it = vars->find(std::string(var));
           if (it == vars->end()) {
             return absl::nullopt;
           }
@@ -605,7 +605,7 @@ class PROTOBUF_EXPORT Printer {
     annotation_lookups_.emplace_back(
         [vars = std::forward<Map>(vars)](
             absl::string_view var) -> absl::optional<AnnotationRecord> {
-          auto it = vars.find(var);
+          auto it = vars.find(std::string(var));
           if (it == vars.end()) {
             return absl::nullopt;
           }
@@ -671,19 +671,6 @@ class PROTOBUF_EXPORT Printer {
     PrintImpl(text, {}, opts);
   }
 
-  // TODO(b/243140651) Delete this once migrating callers to containers with
-  // heterogeneous lookup.
-  void Print(const std::map<std::string, std::string>& vars,
-             absl::string_view text) {
-    PrintOptions opts;
-    opts.checks_are_debug_only = true;
-    opts.use_substitution_map = true;
-    opts.allow_digit_substitions = false;
-
-    auto pop = WithVars<std::map<std::string, std::string>, std::string>(&vars);
-    PrintImpl(text, {}, opts);
-  }
-
   template <typename... Args>
   void Print(absl::string_view text, const Args&... args) {
     static_assert(sizeof...(args) % 2 == 0, "");
@@ -691,10 +678,10 @@ class PROTOBUF_EXPORT Printer {
     // Include an extra arg, since a zero-length array is ill-formed, and
     // MSVC complains.
     absl::string_view vars[] = {args..., ""};
-    absl::flat_hash_map<absl::string_view, absl::string_view> map;
+    absl::flat_hash_map<std::string, std::string> map;
     map.reserve(sizeof...(args) / 2);
     for (size_t i = 0; i < sizeof...(args); i += 2) {
-      map.emplace(vars[i], vars[i + 1]);
+      map.emplace(std::string(vars[i]), std::string(vars[i + 1]));
     }
 
     Print(map, text);
@@ -751,7 +738,7 @@ class PROTOBUF_EXPORT Printer {
   // FormatInternal is a helper function not meant to use directly, use
   // compiler::cpp::Formatter instead.
   void FormatInternal(absl::Span<const std::string> args,
-                      const absl::flat_hash_map<std::string, std::string>& vars,
+                      const std::map<std::string, std::string>& vars,
                       absl::string_view format) {
     PrintOptions opts;
     opts.use_curly_brace_substitutions = true;

third_party/utf8_range

@@ -1 +1 @@
-Subproject commit 45fbf543fec00020a08650791a37575319a3ea1d
+Subproject commit a67b76f9f40107f2c78a5aa860bb6ce37ed83d85