From 86594306aa85eddbea39eddd180a2d198f835930 Mon Sep 17 00:00:00 2001 From: Mike Kruskal Date: Wed, 19 Oct 2022 16:56:53 -0700 Subject: [PATCH] Sync from Piper @482325250 PROTOBUF_SYNC_PIPER --- .../compiler/command_line_interface.cc | 4 +- .../compiler/command_line_interface.h | 6 +- .../protobuf/compiler/cpp/enum_field.cc | 3 +- src/google/protobuf/compiler/cpp/extension.h | 3 +- src/google/protobuf/compiler/cpp/field.cc | 32 ++++----- src/google/protobuf/compiler/cpp/field.h | 12 ++-- src/google/protobuf/compiler/cpp/file.h | 3 +- src/google/protobuf/compiler/cpp/helpers.cc | 8 +-- src/google/protobuf/compiler/cpp/helpers.h | 16 ++--- src/google/protobuf/compiler/cpp/map_field.cc | 10 ++- src/google/protobuf/compiler/cpp/message.cc | 22 +++--- src/google/protobuf/compiler/cpp/message.h | 4 +- .../protobuf/compiler/cpp/message_field.cc | 10 ++- .../compiler/cpp/parse_function_generator.cc | 3 +- .../compiler/cpp/parse_function_generator.h | 15 ++-- .../protobuf/compiler/cpp/primitive_field.cc | 8 +-- src/google/protobuf/compiler/cpp/service.h | 5 +- .../protobuf/compiler/cpp/string_field.cc | 8 +-- .../compiler/csharp/csharp_field_base.cc | 4 +- .../compiler/csharp/csharp_field_base.h | 8 +-- .../compiler/csharp/csharp_message.cc | 59 +++++++-------- src/google/protobuf/compiler/java/enum.cc | 7 +- .../protobuf/compiler/java/enum_field.cc | 3 +- .../protobuf/compiler/java/enum_field.h | 5 +- .../protobuf/compiler/java/enum_field_lite.cc | 26 +++---- .../protobuf/compiler/java/enum_field_lite.h | 5 +- .../protobuf/compiler/java/enum_lite.cc | 7 +- .../protobuf/compiler/java/extension.cc | 8 +-- src/google/protobuf/compiler/java/extension.h | 11 ++- .../protobuf/compiler/java/extension_lite.cc | 3 +- src/google/protobuf/compiler/java/field.cc | 25 +++---- src/google/protobuf/compiler/java/field.h | 18 +++-- src/google/protobuf/compiler/java/helpers.cc | 9 +-- src/google/protobuf/compiler/java/helpers.h | 9 +-- .../protobuf/compiler/java/map_field.cc | 52 ++++++-------- src/google/protobuf/compiler/java/map_field.h | 2 +- .../protobuf/compiler/java/map_field_lite.cc | 8 +-- .../protobuf/compiler/java/map_field_lite.h | 2 +- src/google/protobuf/compiler/java/message.cc | 10 +-- .../protobuf/compiler/java/message_builder.cc | 2 +- .../compiler/java/message_builder_lite.cc | 2 +- .../protobuf/compiler/java/message_field.cc | 26 ++++--- .../protobuf/compiler/java/message_field.h | 4 +- .../compiler/java/message_field_lite.cc | 23 +++--- .../compiler/java/message_field_lite.h | 4 +- .../protobuf/compiler/java/message_lite.cc | 7 +- .../protobuf/compiler/java/primitive_field.cc | 72 +++++++++---------- .../protobuf/compiler/java/primitive_field.h | 4 +- .../compiler/java/primitive_field_lite.cc | 71 +++++++++--------- .../compiler/java/primitive_field_lite.h | 4 +- src/google/protobuf/compiler/java/service.cc | 14 ++-- .../protobuf/compiler/java/string_field.cc | 11 +-- .../protobuf/compiler/java/string_field.h | 4 +- .../compiler/java/string_field_lite.cc | 11 +-- .../compiler/java/string_field_lite.h | 4 +- .../compiler/objectivec/enum_field.cc | 6 +- .../protobuf/compiler/objectivec/extension.cc | 5 +- .../protobuf/compiler/objectivec/field.cc | 6 +- .../protobuf/compiler/objectivec/field.h | 3 +- .../protobuf/compiler/objectivec/file.cc | 2 +- .../compiler/objectivec/import_writer.cc | 10 ++- .../compiler/objectivec/import_writer.h | 3 +- .../protobuf/compiler/objectivec/message.cc | 3 +- .../compiler/objectivec/message_field.cc | 6 +- .../protobuf/compiler/objectivec/names.cc | 29 ++++---- .../protobuf/compiler/objectivec/oneof.h | 3 +- .../compiler/objectivec/primitive_field.cc | 6 +- .../protobuf/compiler/python/generator.cc | 29 ++++---- .../protobuf/compiler/python/pyi_generator.h | 3 +- src/google/protobuf/io/printer.h | 33 +++------ third_party/utf8_range | 2 +- 71 files changed, 392 insertions(+), 473 deletions(-) diff --git a/src/google/protobuf/compiler/command_line_interface.cc b/src/google/protobuf/compiler/command_line_interface.cc index 4ac86d4bd0..6b6ca1b498 100644 --- a/src/google/protobuf/compiler/command_line_interface.cc +++ b/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 files_; + std::map files_; const std::vector& 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::const_iterator i = + for (std::map::const_iterator i = plugin_parameters_.begin(); i != plugin_parameters_.end(); ++i) { if (plugins_.find(i->first) != plugins_.end()) { diff --git a/src/google/protobuf/compiler/command_line_interface.h b/src/google/protobuf/compiler/command_line_interface.h index 7e1cd58f5d..92454145b7 100644 --- a/src/google/protobuf/compiler/command_line_interface.h +++ b/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 generator_parameters_; + std::map generator_parameters_; // Similar to generator_parameters_, but stores the parameters for plugins. - absl::flat_hash_map plugin_parameters_; + std::map 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 plugins_; + std::map plugins_; // Stuff parsed from command line. enum Mode { diff --git a/src/google/protobuf/compiler/cpp/enum_field.cc b/src/google/protobuf/compiler/cpp/enum_field.cc index c1df1b5307..0ac1451c7d 100644 --- a/src/google/protobuf/compiler/cpp/enum_field.cc +++ b/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* variables, + std::map* variables, const Options& options) { SetCommonFieldVariables(descriptor, variables, options); const EnumValueDescriptor* default_value = descriptor->default_value_enum(); diff --git a/src/google/protobuf/compiler/cpp/extension.h b/src/google/protobuf/compiler/cpp/extension.h index c8097529b7..1c0e020b99 100644 --- a/src/google/protobuf/compiler/cpp/extension.h +++ b/src/google/protobuf/compiler/cpp/extension.h @@ -38,7 +38,6 @@ #include #include -#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 variables_; + std::map variables_; }; } // namespace cpp diff --git a/src/google/protobuf/compiler/cpp/field.cc b/src/google/protobuf/compiler/cpp/field.cc index 7637ff1119..3199dce889 100644 --- a/src/google/protobuf/compiler/cpp/field.cc +++ b/src/google/protobuf/compiler/cpp/field.cc @@ -38,7 +38,6 @@ #include #include -#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( - const Options& options, absl::string_view annotation_name, - absl::string_view substitute_template_prefix, - absl::string_view prepared_template, int field_index, - absl::string_view access_type, - absl::flat_hash_map* variables) { +void MaySetAnnotationVariable(const Options& options, + absl::string_view annotation_name, + absl::string_view substitute_template_prefix, + absl::string_view prepared_template, + int field_index, absl::string_view access_type, + std::map* 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( - const FieldDescriptor* descriptor, const Options& options, - absl::flat_hash_map* variables) { +void AddAccessorAnnotations(const FieldDescriptor* descriptor, + const Options& options, + std::map* 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 FieldVars( // TODO(b/245791219): Refactor AddAccessorAnnotations to avoid this // workaround. - absl::flat_hash_map workaround = { + std::map workaround = { {"field", vars["field"]}, {"tracker", "Impl_::_tracker_"}, }; @@ -274,10 +273,9 @@ absl::flat_hash_map FieldVars( return vars; } -void SetCommonFieldVariables( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables, - const Options& options) { +void SetCommonFieldVariables(const FieldDescriptor* descriptor, + std::map* variables, + const Options& options) { SetCommonMessageDataVariables(descriptor->containing_type(), variables); for (auto& pair : FieldVars(descriptor, options)) { @@ -296,14 +294,14 @@ absl::flat_hash_map OneofFieldVars( void SetCommonOneofFieldVariables( const FieldDescriptor* descriptor, - absl::flat_hash_map* variables) { + std::map* 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; } diff --git a/src/google/protobuf/compiler/cpp/field.h b/src/google/protobuf/compiler/cpp/field.h index 7a745f4d17..db0d64d30e 100644 --- a/src/google/protobuf/compiler/cpp/field.h +++ b/src/google/protobuf/compiler/cpp/field.h @@ -41,7 +41,6 @@ #include #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 OneofFieldVars( // field code generators. // ['name', 'index', 'number', 'classname', 'declared_type', 'tag_size', // 'deprecation']. -void SetCommonFieldVariables( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables, - const Options& options); +void SetCommonFieldVariables(const FieldDescriptor* descriptor, + std::map* variables, + const Options& options); void SetCommonOneofFieldVariables( const FieldDescriptor* descriptor, - absl::flat_hash_map* variables); + std::map* variables); class FieldGenerator { public: @@ -228,7 +226,7 @@ class FieldGenerator { protected: const FieldDescriptor* descriptor_; const Options& options_; - absl::flat_hash_map variables_; + std::map variables_; }; // Convenience class which constructs FieldGenerators for a Descriptor. diff --git a/src/google/protobuf/compiler/cpp/file.h b/src/google/protobuf/compiler/cpp/file.h index a1d2bcc67a..cd38345043 100644 --- a/src/google/protobuf/compiler/cpp/file.h +++ b/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 variables_; + std::map 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. diff --git a/src/google/protobuf/compiler/cpp/helpers.cc b/src/google/protobuf/compiler/cpp/helpers.cc index 1f40d3d440..383629f4f1 100644 --- a/src/google/protobuf/compiler/cpp/helpers.cc +++ b/src/google/protobuf/compiler/cpp/helpers.cc @@ -252,7 +252,7 @@ absl::flat_hash_map MessageVars( void SetCommonMessageDataVariables( const Descriptor* descriptor, - absl::flat_hash_map* variables) { + std::map* variables) { for (auto& pair : MessageVars(descriptor)) { variables->emplace(pair); } @@ -286,9 +286,9 @@ absl::flat_hash_map UnknownFieldsVars( }; } -void SetUnknownFieldsVariable( - const Descriptor* descriptor, const Options& options, - absl::flat_hash_map* variables) { +void SetUnknownFieldsVariable(const Descriptor* descriptor, + const Options& options, + std::map* variables) { for (auto& pair : UnknownFieldsVars(descriptor, options)) { variables->emplace(pair); } diff --git a/src/google/protobuf/compiler/cpp/helpers.h b/src/google/protobuf/compiler/cpp/helpers.h index dbd2dd56c5..4967452ca8 100644 --- a/src/google/protobuf/compiler/cpp/helpers.h +++ b/src/google/protobuf/compiler/cpp/helpers.h @@ -94,14 +94,14 @@ absl::flat_hash_map MessageVars( // Variables to access message data from the message scope. void SetCommonMessageDataVariables( const Descriptor* descriptor, - absl::flat_hash_map* variables); + std::map* variables); absl::flat_hash_map UnknownFieldsVars( const Descriptor* desc, const Options& opts); -void SetUnknownFieldsVariable( - const Descriptor* descriptor, const Options& options, - absl::flat_hash_map* variables); +void SetUnknownFieldsVariable(const Descriptor* descriptor, + const Options& options, + std::map* 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& vars) + const std::map& vars) : printer_(printer), vars_(vars) {} template @@ -802,7 +802,7 @@ class PROTOC_EXPORT Formatter { vars_[key] = ToString(value); } - void AddMap(const absl::flat_hash_map& vars) { + void AddMap(const std::map& 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 vars_; + std::map vars_; }; private: io::Printer* printer_; - absl::flat_hash_map vars_; + std::map vars_; // Convenience overloads to accept different types as arguments. static std::string ToString(const std::string& s) { return s; } diff --git a/src/google/protobuf/compiler/cpp/map_field.cc b/src/google/protobuf/compiler/cpp/map_field.cc index 0518c6acd3..e320a435b8 100644 --- a/src/google/protobuf/compiler/cpp/map_field.cc +++ b/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( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables, - const Options& options) { +void SetMessageVariables(const FieldDescriptor* descriptor, + std::map* variables, + const Options& options) { SetCommonFieldVariables(descriptor, variables, options); (*variables)["type"] = ClassName(descriptor->message_type(), false); (*variables)["full_name"] = descriptor->full_name(); diff --git a/src/google/protobuf/compiler/cpp/message.cc b/src/google/protobuf/compiler/cpp/message.cc index f527c4e814..38f60946eb 100644 --- a/src/google/protobuf/compiler/cpp/message.cc +++ b/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* variables) { + std::map* variables) { GOOGLE_CHECK(IsMapEntryMessage(descriptor)); - absl::flat_hash_map& vars = *variables; + std::map& 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& has_bit_indices_; const AccessInfoMap* access_info_map_; const double cold_threshold_; - absl::flat_hash_map variables_; + std::map variables_; int limit_chunk_ = -1; }; @@ -640,11 +640,11 @@ absl::flat_hash_map ClassVars(const Descriptor* desc, // =================================================================== -MessageGenerator::MessageGenerator( - const Descriptor* descriptor, - const absl::flat_hash_map&, - int index_in_file_messages, const Options& options, - MessageSCCAnalyzer* scc_analyzer) +MessageGenerator::MessageGenerator(const Descriptor* descriptor, + const std::map&, + int index_in_file_messages, + const Options& options, + 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 vars; + std::map 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 vars; + std::map 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 vars = variables_; + std::map vars = variables_; vars["start"] = absl::StrCat(range->start); vars["end"] = absl::StrCat(range->end); Formatter format(p, vars); diff --git a/src/google/protobuf/compiler/cpp/message.h b/src/google/protobuf/compiler/cpp/message.h index 0c9409df72..019660692a 100644 --- a/src/google/protobuf/compiler/cpp/message.h +++ b/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& ignored, + const std::map& 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 variables_; + std::map variables_; }; diff --git a/src/google/protobuf/compiler/cpp/message_field.cc b/src/google/protobuf/compiler/cpp/message_field.cc index 06db2fb35b..e8d2a74dae 100644 --- a/src/google/protobuf/compiler/cpp/message_field.cc +++ b/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( - const FieldDescriptor* descriptor, const Options& options, - bool implicit_weak, - absl::flat_hash_map* variables) { +void SetMessageVariables(const FieldDescriptor* descriptor, + const Options& options, bool implicit_weak, + std::map* variables) { SetCommonFieldVariables(descriptor, variables, options); (*variables)["type"] = FieldMessageTypeName(descriptor, options); (*variables)["casted_member"] = ReinterpretCast( diff --git a/src/google/protobuf/compiler/cpp/parse_function_generator.cc b/src/google/protobuf/compiler/cpp/parse_function_generator.cc index 74fdbd2fdd..74a9a9899d 100644 --- a/src/google/protobuf/compiler/cpp/parse_function_generator.cc +++ b/src/google/protobuf/compiler/cpp/parse_function_generator.cc @@ -38,7 +38,6 @@ #include #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& has_bit_indices, const std::vector& inlined_string_indices, const Options& options, MessageSCCAnalyzer* scc_analyzer, - const absl::flat_hash_map& vars) + const std::map& vars) : descriptor_(descriptor), scc_analyzer_(scc_analyzer), options_(options), diff --git a/src/google/protobuf/compiler/cpp/parse_function_generator.h b/src/google/protobuf/compiler/cpp/parse_function_generator.h index 33ed17c07c..b55feda112 100644 --- a/src/google/protobuf/compiler/cpp/parse_function_generator.h +++ b/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( - const Descriptor* descriptor, int max_has_bit_index, - const std::vector& has_bit_indices, - const std::vector& inlined_string_indices, const Options& options, - MessageSCCAnalyzer* scc_analyzer, - const absl::flat_hash_map& vars); + ParseFunctionGenerator(const Descriptor* descriptor, int max_has_bit_index, + const std::vector& has_bit_indices, + const std::vector& inlined_string_indices, + const Options& options, + MessageSCCAnalyzer* scc_analyzer, + const std::map& 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 variables_; + std::map variables_; std::unique_ptr tc_table_info_; std::vector inlined_string_indices_; const std::vector ordered_fields_; diff --git a/src/google/protobuf/compiler/cpp/primitive_field.cc b/src/google/protobuf/compiler/cpp/primitive_field.cc index 143f6e578d..b2144c3111 100644 --- a/src/google/protobuf/compiler/cpp/primitive_field.cc +++ b/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( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables, - const Options& options) { +void SetPrimitiveVariables(const FieldDescriptor* descriptor, + std::map* variables, + const Options& options) { SetCommonFieldVariables(descriptor, variables, options); (*variables)["type"] = PrimitiveTypeName(options, descriptor->cpp_type()); (*variables)["default"] = DefaultValue(options, descriptor); diff --git a/src/google/protobuf/compiler/cpp/service.h b/src/google/protobuf/compiler/cpp/service.h index be11bf7221..34b891423b 100644 --- a/src/google/protobuf/compiler/cpp/service.h +++ b/src/google/protobuf/compiler/cpp/service.h @@ -39,7 +39,6 @@ #include #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& vars, + const std::map& 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 vars_; + std::map vars_; int index_in_metadata_; diff --git a/src/google/protobuf/compiler/cpp/string_field.cc b/src/google/protobuf/compiler/cpp/string_field.cc index 2730f3dbf5..b1aadfb56e 100644 --- a/src/google/protobuf/compiler/cpp/string_field.cc +++ b/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( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables, - const Options& options) { +void SetStringVariables(const FieldDescriptor* descriptor, + std::map* variables, + const Options& options) { SetCommonFieldVariables(descriptor, variables, options); const std::string kNS = "::" + ProtobufNamespace(options) + "::internal::"; diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.cc b/src/google/protobuf/compiler/csharp/csharp_field_base.cc index d934300d3e..bc45d740ba 100644 --- a/src/google/protobuf/compiler/csharp/csharp_field_base.cc +++ b/src/google/protobuf/compiler/csharp/csharp_field_base.cc @@ -52,7 +52,7 @@ namespace compiler { namespace csharp { void FieldGeneratorBase::SetCommonFieldVariables( - absl::flat_hash_map* variables) { + std::map* 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* variables) { + std::map* variables) { (*variables)["oneof_name"] = oneof_name(); if (SupportsPresenceApi(descriptor_)) { (*variables)["has_property_check"] = "Has" + property_name(); diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.h b/src/google/protobuf/compiler/csharp/csharp_field_base.h index 719438eea2..75fe19bfb3 100644 --- a/src/google/protobuf/compiler/csharp/csharp_field_base.h +++ b/src/google/protobuf/compiler/csharp/csharp_field_base.h @@ -34,7 +34,6 @@ #include #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 variables_; + std::map 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* variables); + std::map* 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( - absl::flat_hash_map* variables); + void SetCommonFieldVariables(std::map* variables); std::string GetStringDefaultValueInternal(const FieldDescriptor* descriptor); std::string GetBytesDefaultValueInternal(const FieldDescriptor* descriptor); }; diff --git a/src/google/protobuf/compiler/csharp/csharp_message.cc b/src/google/protobuf/compiler/csharp/csharp_message.cc index 7d03ccf1c6..bdbd480a61 100644 --- a/src/google/protobuf/compiler/csharp/csharp_message.cc +++ b/src/google/protobuf/compiler/csharp/csharp_message.cc @@ -35,14 +35,13 @@ #include #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 vars; + std::map 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 vars; + std::map 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 vars; - vars["class_name"] = class_name(); + std::map vars; + vars["class_name"] = class_name(); - // Equality - WriteGeneratedCodeAttributes(printer); - printer->Print(vars, - "public override bool Equals(object other) {\n" - " return Equals(other as $class_name$);\n" - "}\n\n"); - WriteGeneratedCodeAttributes(printer); - printer->Print(vars, - "public bool Equals($class_name$ other) {\n" - " if (ReferenceEquals(other, null)) {\n" - " return false;\n" - " }\n" - " if (ReferenceEquals(other, this)) {\n" - " return true;\n" - " }\n"); - printer->Indent(); - for (int i = 0; i < descriptor_->field_count(); i++) { - std::unique_ptr generator( - CreateFieldGeneratorInternal(descriptor_->field(i))); - generator->WriteEquals(printer); - } + // Equality + WriteGeneratedCodeAttributes(printer); + printer->Print( + vars, + "public override bool Equals(object other) {\n" + " return Equals(other as $class_name$);\n" + "}\n\n"); + WriteGeneratedCodeAttributes(printer); + printer->Print( + vars, + "public bool Equals($class_name$ other) {\n" + " if (ReferenceEquals(other, null)) {\n" + " return false;\n" + " }\n" + " if (ReferenceEquals(other, this)) {\n" + " return true;\n" + " }\n"); + printer->Indent(); + for (int i = 0; i < descriptor_->field_count(); i++) { + std::unique_ptr 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 vars; + std::map 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 vars; + std::map vars; vars["maybe_ref_input"] = use_parse_context ? "ref input" : "input"; printer->Print( diff --git a/src/google/protobuf/compiler/java/enum.cc b/src/google/protobuf/compiler/java/enum.cc index 5a1a2b0fe6..788c9dd60f 100644 --- a/src/google/protobuf/compiler/java/enum.cc +++ b/src/google/protobuf/compiler/java/enum.cc @@ -38,7 +38,6 @@ #include #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 vars; + std::map 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 vars; + std::map 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 vars; + std::map vars; vars["name"] = descriptor_->value(i)->name(); vars["number"] = absl::StrCat(descriptor_->value(i)->number()); vars["{"] = ""; diff --git a/src/google/protobuf/compiler/java/enum_field.cc b/src/google/protobuf/compiler/java/enum_field.cc index ed5413c9d1..b6c8dc796c 100644 --- a/src/google/protobuf/compiler/java/enum_field.cc +++ b/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* variables, + std::map* variables, Context* context) { SetCommonFieldVariables(descriptor, info, variables); diff --git a/src/google/protobuf/compiler/java/enum_field.h b/src/google/protobuf/compiler/java/enum_field.h index 09960c6b06..25ab0738da 100644 --- a/src/google/protobuf/compiler/java/enum_field.h +++ b/src/google/protobuf/compiler/java/enum_field.h @@ -38,7 +38,6 @@ #include #include -#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 variables_; + std::map variables_; ClassNameResolver* name_resolver_; }; @@ -154,7 +153,7 @@ class RepeatedImmutableEnumFieldGenerator : public ImmutableFieldGenerator { private: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; }; diff --git a/src/google/protobuf/compiler/java/enum_field_lite.cc b/src/google/protobuf/compiler/java/enum_field_lite.cc index e9861245dd..470bc9d2fd 100644 --- a/src/google/protobuf/compiler/java/enum_field_lite.cc +++ b/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* variables, + std::map* 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( - "kt_deprecation", + (*variables)["kt_deprecation"] = descriptor->options().deprecated() - ? absl::StrCat("@kotlin.Deprecated(message = \"Field ", - (*variables)["name"], " is deprecated\") ") - : ""); + ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] + + " 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", - absl::StrCat((*variables)["name"], "_ != ", - (*variables)["default"], ".getNumber()")); + (*variables)["is_field_present_message"] = + (*variables)["name"] + "_ != " + (*variables)["default"] + + ".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", - absl::StrCat((*variables)["type"], ".UNRECOGNIZED")); + (*variables)["unknown"] = (*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 diff --git a/src/google/protobuf/compiler/java/enum_field_lite.h b/src/google/protobuf/compiler/java/enum_field_lite.h index e2319bdba9..8d7a7d1cf4 100644 --- a/src/google/protobuf/compiler/java/enum_field_lite.h +++ b/src/google/protobuf/compiler/java/enum_field_lite.h @@ -39,7 +39,6 @@ #include #include -#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 variables_; + std::map variables_; const int messageBitIndex_; Context* context_; ClassNameResolver* name_resolver_; @@ -132,7 +131,7 @@ class RepeatedImmutableEnumFieldLiteGenerator private: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; Context* context_; ClassNameResolver* name_resolver_; }; diff --git a/src/google/protobuf/compiler/java/enum_lite.cc b/src/google/protobuf/compiler/java/enum_lite.cc index 7bb7478898..47cae62bc2 100644 --- a/src/google/protobuf/compiler/java/enum_lite.cc +++ b/src/google/protobuf/compiler/java/enum_lite.cc @@ -38,7 +38,6 @@ #include #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 vars; + std::map 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 vars; + std::map 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 vars; + std::map vars; vars["name"] = descriptor_->value(i)->name(); vars["number"] = absl::StrCat(descriptor_->value(i)->number()); vars["{"] = ""; diff --git a/src/google/protobuf/compiler/java/extension.cc b/src/google/protobuf/compiler/java/extension.cc index 1bee360479..24a392edd8 100644 --- a/src/google/protobuf/compiler/java/extension.cc +++ b/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* vars_pointer, - Context* context) { - absl::flat_hash_map& vars = *vars_pointer; + std::map* vars_pointer, Context* context) { + std::map& 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 vars; + std::map vars; const bool kUseImmutableNames = true; InitTemplateVars(descriptor_, scope_, kUseImmutableNames, name_resolver_, &vars, context_); diff --git a/src/google/protobuf/compiler/java/extension.h b/src/google/protobuf/compiler/java/extension.h index e2df9ed5d2..b9dc99597b 100644 --- a/src/google/protobuf/compiler/java/extension.h +++ b/src/google/protobuf/compiler/java/extension.h @@ -38,7 +38,6 @@ #include #include -#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( - const FieldDescriptor* descriptor, const std::string& scope, - bool immutable, ClassNameResolver* name_resolver, - absl::flat_hash_map* vars_pointer, - Context* context); + static void InitTemplateVars(const FieldDescriptor* descriptor, + const std::string& scope, bool immutable, + ClassNameResolver* name_resolver, + std::map* vars_pointer, + Context* context); }; class ImmutableExtensionGenerator : public ExtensionGenerator { diff --git a/src/google/protobuf/compiler/java/extension_lite.cc b/src/google/protobuf/compiler/java/extension_lite.cc index f6d7581db7..e18dc6536a 100644 --- a/src/google/protobuf/compiler/java/extension_lite.cc +++ b/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 vars; + std::map vars; const bool kUseImmutableNames = true; InitTemplateVars(descriptor_, scope_, kUseImmutableNames, name_resolver_, &vars, context_); diff --git a/src/google/protobuf/compiler/java/field.cc b/src/google/protobuf/compiler/java/field.cc index 49648503bb..831f88ab2d 100644 --- a/src/google/protobuf/compiler/java/field.cc +++ b/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::~FieldGeneratorMap() {} -void SetCommonFieldVariables( - const FieldDescriptor* descriptor, const FieldGeneratorInfo* info, - absl::flat_hash_map* variables) { +void SetCommonFieldVariables(const FieldDescriptor* descriptor, + const FieldGeneratorInfo* info, + std::map* 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( - "annotation_field_type", - absl::StrCat((*variables)["annotation_field_type"], "_PACKED")); + (*variables)["annotation_field_type"] = + (*variables)["annotation_field_type"] + "_PACKED"; } } } -void SetCommonOneofVariables( - const FieldDescriptor* descriptor, const OneofGeneratorInfo* info, - absl::flat_hash_map* variables) { +void SetCommonOneofVariables(const FieldDescriptor* descriptor, + const OneofGeneratorInfo* info, + std::map* 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( - const absl::flat_hash_map& variables, - io::Printer* printer) { - const absl::flat_hash_map::const_iterator it = +void PrintExtraFieldInfo(const std::map& variables, + io::Printer* printer) { + const std::map::const_iterator it = variables.find("disambiguated_reason"); if (it != variables.end() && !it->second.empty()) { printer->Print( diff --git a/src/google/protobuf/compiler/java/field.h b/src/google/protobuf/compiler/java/field.h index bcd644b73e..5ac57cd4e1 100644 --- a/src/google/protobuf/compiler/java/field.h +++ b/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( - const FieldDescriptor* descriptor, const FieldGeneratorInfo* info, - absl::flat_hash_map* variables); +void SetCommonFieldVariables(const FieldDescriptor* descriptor, + const FieldGeneratorInfo* info, + std::map* variables); // Set some common oneof variables used in OneofFieldGenerators. -void SetCommonOneofVariables( - const FieldDescriptor* descriptor, const OneofGeneratorInfo* info, - absl::flat_hash_map* variables); +void SetCommonOneofVariables(const FieldDescriptor* descriptor, + const OneofGeneratorInfo* info, + std::map* variables); // Print useful comments before a field's accessors. -void PrintExtraFieldInfo( - const absl::flat_hash_map& variables, - io::Printer* printer); +void PrintExtraFieldInfo(const std::map& variables, + io::Printer* printer); } // namespace java } // namespace compiler diff --git a/src/google/protobuf/compiler/java/helpers.cc b/src/google/protobuf/compiler/java/helpers.cc index 700dc61e90..d13941c6ed 100644 --- a/src/google/protobuf/compiler/java/helpers.cc +++ b/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( - io::Printer* printer, const FieldDescriptor* descriptor, - const absl::flat_hash_map& variables, - const char* var_name, const char* terminating_string, bool enforce_lite) { +void PrintEnumVerifierLogic(io::Printer* printer, + const FieldDescriptor* descriptor, + const std::map& variables, + 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( diff --git a/src/google/protobuf/compiler/java/helpers.h b/src/google/protobuf/compiler/java/helpers.h index d068375c66..9273ae3c0b 100644 --- a/src/google/protobuf/compiler/java/helpers.h +++ b/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( - io::Printer* printer, const FieldDescriptor* descriptor, - const absl::flat_hash_map& variables, - const char* var_name, const char* terminating_string, bool enforce_lite); +void PrintEnumVerifierLogic(io::Printer* printer, + const FieldDescriptor* descriptor, + const std::map& variables, + 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. diff --git a/src/google/protobuf/compiler/java/map_field.cc b/src/google/protobuf/compiler/java/map_field.cc index c739a37a83..2b69bb6e29 100644 --- a/src/google/protobuf/compiler/java/map_field.cc +++ b/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( - const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex, - const FieldGeneratorInfo* info, Context* context, - absl::flat_hash_map* variables) { +void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex, + int builderBitIndex, const FieldGeneratorInfo* info, + Context* context, + std::map* 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"]); + (*variables)["value_type_pass_through_nullness"] = + (*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( - "value_enum_type_pass_through_nullness", - absl::StrCat(pass_through_nullness, (*variables)["value_enum_type"])); + (*variables)["value_enum_type_pass_through_nullness"] = + pass_through_nullness + (*variables)["value_enum_type"]; if (SupportUnknownEnumValue(descriptor->file())) { // Map unknown values to a special UNRECOGNIZED value if supported. - variables->emplace( - "unrecognized_value", - absl::StrCat((*variables)["value_enum_type"], ".UNRECOGNIZED")); + (*variables)["unrecognized_value"] = + (*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( - "value_type_pass_through_nullness", - absl::StrCat( - (IsReferenceType(valueJavaType) ? pass_through_nullness : ""), - (*variables)["value_type"])); + (*variables)["value_type_pass_through_nullness"] = + (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", - absl::StrCat((*variables)["boxed_key_type"], ", ", - (*variables)["boxed_value_type"])); + (*variables)["type_parameters"] = + (*variables)["boxed_key_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( - "kt_deprecation", + (*variables)["kt_deprecation"] = descriptor->options().deprecated() - ? absl::StrCat("@kotlin.Deprecated(message = \"Field ", - (*variables)["name"], " is deprecated\") ") - : ""); + ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] + + " is deprecated\") " + : ""; (*variables)["on_changed"] = "onChanged();"; - variables->emplace("default_entry", - absl::StrCat((*variables)["capitalized_name"], - "DefaultEntryHolder.defaultEntry")); - variables->emplace("map_field_parameter", (*variables)["default_entry"]); + (*variables)["default_entry"] = + (*variables)["capitalized_name"] + "DefaultEntryHolder.defaultEntry"; + (*variables)["map_field_parameter"] = (*variables)["default_entry"]; (*variables)["descriptor"] = name_resolver->GetImmutableClassName(descriptor->file()) + ".internal_" + UniqueFileScopeIdentifier(descriptor->message_type()) + "_descriptor, "; diff --git a/src/google/protobuf/compiler/java/map_field.h b/src/google/protobuf/compiler/java/map_field.h index 611fd15575..434150820b 100644 --- a/src/google/protobuf/compiler/java/map_field.h +++ b/src/google/protobuf/compiler/java/map_field.h @@ -68,7 +68,7 @@ class ImmutableMapFieldGenerator : public ImmutableFieldGenerator { private: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; Context* context_; void GenerateMapGetters(io::Printer* printer) const; diff --git a/src/google/protobuf/compiler/java/map_field_lite.cc b/src/google/protobuf/compiler/java/map_field_lite.cc index 0eff2a3986..22bc306586 100644 --- a/src/google/protobuf/compiler/java/map_field_lite.cc +++ b/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( - const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex, - const FieldGeneratorInfo* info, Context* context, - absl::flat_hash_map* variables) { +void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex, + int builderBitIndex, const FieldGeneratorInfo* info, + Context* context, + std::map* variables) { SetCommonFieldVariables(descriptor, info, variables); ClassNameResolver* name_resolver = context->GetNameResolver(); diff --git a/src/google/protobuf/compiler/java/map_field_lite.h b/src/google/protobuf/compiler/java/map_field_lite.h index aac8b003ad..46a2d9f884 100644 --- a/src/google/protobuf/compiler/java/map_field_lite.h +++ b/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 variables_; + std::map variables_; Context* context_; ClassNameResolver* name_resolver_; }; diff --git a/src/google/protobuf/compiler/java/message.cc b/src/google/protobuf/compiler/java/message.cc index 561ffc6720..eae7bb3bcc 100644 --- a/src/google/protobuf/compiler/java/message.cc +++ b/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 vars; + std::map 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 vars; + std::map 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 vars; + std::map 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 variables; + std::map 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 vars; + std::map vars; for (auto oneof : oneofs_) { vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name; vars["oneof_capitalized_name"] = diff --git a/src/google/protobuf/compiler/java/message_builder.cc b/src/google/protobuf/compiler/java/message_builder.cc index 1bfc5e449a..150c4e6c4c 100644 --- a/src/google/protobuf/compiler/java/message_builder.cc +++ b/src/google/protobuf/compiler/java/message_builder.cc @@ -126,7 +126,7 @@ void MessageBuilderGenerator::Generate(io::Printer* printer) { } // oneof - absl::flat_hash_map vars; + std::map vars; for (auto oneof : oneofs_) { vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name; vars["oneof_capitalized_name"] = diff --git a/src/google/protobuf/compiler/java/message_builder_lite.cc b/src/google/protobuf/compiler/java/message_builder_lite.cc index 89f3bdc698..1f9d13e9b6 100644 --- a/src/google/protobuf/compiler/java/message_builder_lite.cc +++ b/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 vars = { + std::map vars = { {"{", ""}, {"}", ""}, {"classname", name_resolver_->GetImmutableClassName(descriptor_)}, diff --git a/src/google/protobuf/compiler/java/message_field.cc b/src/google/protobuf/compiler/java/message_field.cc index 10888aeafe..0e06ed77d8 100644 --- a/src/google/protobuf/compiler/java/message_field.cc +++ b/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( - const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex, - const FieldGeneratorInfo* info, ClassNameResolver* name_resolver, - absl::flat_hash_map* variables, - Context* context) { +void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex, + int builderBitIndex, const FieldGeneratorInfo* info, + ClassNameResolver* name_resolver, + std::map* variables, + 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( - "kt_deprecation", + (*variables)["kt_deprecation"] = descriptor->options().deprecated() - ? absl::StrCat("@kotlin.Deprecated(message = \"Field ", - (*variables)["name"], " is deprecated\") ") - : ""); + ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] + + " 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", - absl::StrCat((*variables)["name"], "_ != null")); + (*variables)["is_field_present_message"] = + (*variables)["name"] + "_ != null"; } // For repeated builders, one bit is used for whether the array is immutable. diff --git a/src/google/protobuf/compiler/java/message_field.h b/src/google/protobuf/compiler/java/message_field.h index ed83183400..4fe5ac7df4 100644 --- a/src/google/protobuf/compiler/java/message_field.h +++ b/src/google/protobuf/compiler/java/message_field.h @@ -92,7 +92,7 @@ class ImmutableMessageFieldGenerator : public ImmutableFieldGenerator { protected: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; Context* context_; @@ -165,7 +165,7 @@ class RepeatedImmutableMessageFieldGenerator : public ImmutableFieldGenerator { protected: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; void PrintNestedBuilderCondition(io::Printer* printer, diff --git a/src/google/protobuf/compiler/java/message_field_lite.cc b/src/google/protobuf/compiler/java/message_field_lite.cc index 42962eb016..d01ccc102d 100644 --- a/src/google/protobuf/compiler/java/message_field_lite.cc +++ b/src/google/protobuf/compiler/java/message_field_lite.cc @@ -56,16 +56,16 @@ namespace java { namespace { -void SetMessageVariables( - const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex, - const FieldGeneratorInfo* info, ClassNameResolver* name_resolver, - absl::flat_hash_map* variables, - Context* context) { +void SetMessageVariables(const FieldDescriptor* descriptor, int messageBitIndex, + int builderBitIndex, const FieldGeneratorInfo* info, + ClassNameResolver* name_resolver, + std::map* variables, + 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( - "kt_deprecation", + (*variables)["kt_deprecation"] = descriptor->options().deprecated() - ? absl::StrCat("@kotlin.Deprecated(message = \"Field ", - (*variables)["name"], " is deprecated\") ") - : ""); + ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] + + " 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"] = diff --git a/src/google/protobuf/compiler/java/message_field_lite.h b/src/google/protobuf/compiler/java/message_field_lite.h index f82bdcf1ba..c5387a6ffe 100644 --- a/src/google/protobuf/compiler/java/message_field_lite.h +++ b/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 variables_; + std::map variables_; const int messageBitIndex_; ClassNameResolver* name_resolver_; Context* context_; @@ -136,7 +136,7 @@ class RepeatedImmutableMessageFieldLiteGenerator protected: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; Context* context_; }; diff --git a/src/google/protobuf/compiler/java/message_lite.cc b/src/google/protobuf/compiler/java/message_lite.cc index 8eae02a3ce..475a30b9f5 100644 --- a/src/google/protobuf/compiler/java/message_lite.cc +++ b/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 variables = { + std::map 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 variables = {{"{", ""}, - {"}", ""}}; + std::map 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 vars = {{"{", ""}, {"}", ""}}; + std::map vars = {{"{", ""}, {"}", ""}}; for (auto oneof : oneofs_) { vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name; vars["oneof_capitalized_name"] = diff --git a/src/google/protobuf/compiler/java/primitive_field.cc b/src/google/protobuf/compiler/java/primitive_field.cc index 8121f000c6..87dbdb6a50 100644 --- a/src/google/protobuf/compiler/java/primitive_field.cc +++ b/src/google/protobuf/compiler/java/primitive_field.cc @@ -57,55 +57,54 @@ using internal::WireFormat; namespace { -void SetPrimitiveVariables( - const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex, - const FieldGeneratorInfo* info, ClassNameResolver* name_resolver, - absl::flat_hash_map* variables, - Context* context) { +void SetPrimitiveVariables(const FieldDescriptor* descriptor, + int messageBitIndex, int builderBitIndex, + const FieldGeneratorInfo* info, + ClassNameResolver* name_resolver, + std::map* 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"); - (*variables)["empty_list"] = - absl::StrCat("empty", capitalized_type, "List()"); - (*variables)["create_list"] = - absl::StrCat("new", capitalized_type, "List()"); + "com.google.protobuf.Internal." + capitalized_type + "List"; + (*variables)["empty_list"] = "empty" + capitalized_type + "List()"; + (*variables)["create_list"] = "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, ">()"); - (*variables)["mutable_copy_list"] = - absl::StrCat("new java.util.ArrayList<", boxed_type, ">(", name, "_)"); + "new java.util.ArrayList<" + (*variables)["boxed_type"] + ">()"; + (*variables)["mutable_copy_list"] = "new java.util.ArrayList<" + + (*variables)["boxed_type"] + ">(" + + (*variables)["name"] + "_)"; (*variables)["empty_list"] = "java.util.Collections.emptyList()"; - (*variables)["name_make_immutable"] = absl::StrCat( - name, "_ = java.util.Collections.unmodifiableList(", name, "_)"); - (*variables)["repeated_get"] = absl::StrCat(name, "_.get"); - (*variables)["repeated_add"] = absl::StrCat(name, "_.add"); - (*variables)["repeated_set"] = absl::StrCat(name, "_.set"); + (*variables)["name_make_immutable"] = + (*variables)["name"] + "_ = java.util.Collections.unmodifiableList(" + + (*variables)["name"] + "_)"; + (*variables)["repeated_get"] = (*variables)["name"] + "_.get"; + (*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, - " is deprecated\") ") + ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] + + " 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( - "java.lang.Double.doubleToRawLongBits(", name, "_) != 0"); + (*variables)["is_field_present_message"] = + "java.lang.Double.doubleToRawLongBits(" + (*variables)["name"] + + "_) != 0"; break; default: - variables->emplace( - "is_field_present_message", - absl::StrCat(name, "_ != ", (*variables)["default"])); + (*variables)["is_field_present_message"] = + (*variables)["name"] + "_ != " + (*variables)["default"]; break; } } diff --git a/src/google/protobuf/compiler/java/primitive_field.h b/src/google/protobuf/compiler/java/primitive_field.h index dd5c1de1b3..d8104ba5f6 100644 --- a/src/google/protobuf/compiler/java/primitive_field.h +++ b/src/google/protobuf/compiler/java/primitive_field.h @@ -92,7 +92,7 @@ class ImmutablePrimitiveFieldGenerator : public ImmutableFieldGenerator { protected: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; }; @@ -155,7 +155,7 @@ class RepeatedImmutablePrimitiveFieldGenerator private: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; }; diff --git a/src/google/protobuf/compiler/java/primitive_field_lite.cc b/src/google/protobuf/compiler/java/primitive_field_lite.cc index cf398b03d4..e370815326 100644 --- a/src/google/protobuf/compiler/java/primitive_field_lite.cc +++ b/src/google/protobuf/compiler/java/primitive_field_lite.cc @@ -66,17 +66,18 @@ bool EnableExperimentalRuntimeForLite() { #endif // !PROTOBUF_EXPERIMENT } -void SetPrimitiveVariables( - const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex, - const FieldGeneratorInfo* info, ClassNameResolver* name_resolver, - absl::flat_hash_map* variables, - Context* context) { +void SetPrimitiveVariables(const FieldDescriptor* descriptor, + int messageBitIndex, int builderBitIndex, + const FieldGeneratorInfo* info, + ClassNameResolver* name_resolver, + std::map* 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( - "com.google.protobuf.Internal.", capitalized_type, "List"); - (*variables)["empty_list"] = - absl::StrCat("empty", capitalized_type, "List()"); + (*variables)["field_list_type"] = + "com.google.protobuf.Internal." + capitalized_type + "List"; + (*variables)["empty_list"] = "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"] = - absl::StrCat("visit", capitalized_type, "List"); + (*variables)["visit_type_list"] = "visit" + capitalized_type + "List"; break; default: - variables->emplace( - "field_list_type", - absl::StrCat("com.google.protobuf.Internal.ProtobufList<", - (*variables)["boxed_type"], ">")); + (*variables)["field_list_type"] = + "com.google.protobuf.Internal.ProtobufList<" + + (*variables)["boxed_type"] + ">"; (*variables)["empty_list"] = "emptyProtobufList()"; (*variables)["make_name_unmodifiable"] = - absl::StrCat(name, "_.makeImmutable()"); - (*variables)["repeated_get"] = absl::StrCat(name, "_.get"); - (*variables)["repeated_add"] = absl::StrCat(name, "_.add"); - (*variables)["repeated_set"] = absl::StrCat(name, "_.set"); + (*variables)["name"] + "_.makeImmutable()"; + (*variables)["repeated_get"] = (*variables)["name"] + "_.get"; + (*variables)["repeated_add"] = (*variables)["name"] + "_.add"; + (*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, - " is deprecated\") ") + ? "@kotlin.Deprecated(message = \"Field " + (*variables)["name"] + + " 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( - "java.lang.Double.doubleToRawLongBits(", name, "_) != 0"); + (*variables)["is_field_present_message"] = + "java.lang.Double.doubleToRawLongBits(" + (*variables)["name"] + + "_) != 0"; break; default: - variables->emplace( - "is_field_present_message", - absl::StrCat(name, "_ != " + (*variables)["default"])); + (*variables)["is_field_present_message"] = + (*variables)["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 diff --git a/src/google/protobuf/compiler/java/primitive_field_lite.h b/src/google/protobuf/compiler/java/primitive_field_lite.h index 3665d4570b..410b7d608f 100644 --- a/src/google/protobuf/compiler/java/primitive_field_lite.h +++ b/src/google/protobuf/compiler/java/primitive_field_lite.h @@ -83,7 +83,7 @@ class ImmutablePrimitiveFieldLiteGenerator protected: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; const int messageBitIndex_; Context* context_; ClassNameResolver* name_resolver_; @@ -133,7 +133,7 @@ class RepeatedImmutablePrimitiveFieldLiteGenerator private: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; Context* context_; ClassNameResolver* name_resolver_; }; diff --git a/src/google/protobuf/compiler/java/service.cc b/src/google/protobuf/compiler/java/service.cc index cb539c7b12..d0c525b8c4 100644 --- a/src/google/protobuf/compiler/java/service.cc +++ b/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 vars; + std::map 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 vars; + std::map 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 vars; + std::map 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 vars; + std::map 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 vars; + std::map 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 vars; + std::map 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 vars; + std::map vars; vars["method"] = UnderscoresToCamelCase(method); vars["input"] = name_resolver_->GetImmutableClassName(method->input_type()); vars["output"] = GetOutput(method); diff --git a/src/google/protobuf/compiler/java/string_field.cc b/src/google/protobuf/compiler/java/string_field.cc index 4d13f1b53f..910ee8e0ee 100644 --- a/src/google/protobuf/compiler/java/string_field.cc +++ b/src/google/protobuf/compiler/java/string_field.cc @@ -59,11 +59,12 @@ using internal::WireFormatLite; namespace { -void SetPrimitiveVariables( - const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex, - const FieldGeneratorInfo* info, ClassNameResolver* name_resolver, - absl::flat_hash_map* variables, - Context* context) { +void SetPrimitiveVariables(const FieldDescriptor* descriptor, + int messageBitIndex, int builderBitIndex, + const FieldGeneratorInfo* info, + ClassNameResolver* name_resolver, + std::map* variables, + Context* context) { SetCommonFieldVariables(descriptor, info, variables); (*variables)["empty_list"] = "com.google.protobuf.LazyStringArrayList.EMPTY"; diff --git a/src/google/protobuf/compiler/java/string_field.h b/src/google/protobuf/compiler/java/string_field.h index 515238e1df..c9b6256d5d 100644 --- a/src/google/protobuf/compiler/java/string_field.h +++ b/src/google/protobuf/compiler/java/string_field.h @@ -91,7 +91,7 @@ class ImmutableStringFieldGenerator : public ImmutableFieldGenerator { protected: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; }; @@ -152,7 +152,7 @@ class RepeatedImmutableStringFieldGenerator : public ImmutableFieldGenerator { private: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; }; diff --git a/src/google/protobuf/compiler/java/string_field_lite.cc b/src/google/protobuf/compiler/java/string_field_lite.cc index 69532a31d2..df86df7876 100644 --- a/src/google/protobuf/compiler/java/string_field_lite.cc +++ b/src/google/protobuf/compiler/java/string_field_lite.cc @@ -59,11 +59,12 @@ using internal::WireFormatLite; namespace { -void SetPrimitiveVariables( - const FieldDescriptor* descriptor, int messageBitIndex, int builderBitIndex, - const FieldGeneratorInfo* info, ClassNameResolver* name_resolver, - absl::flat_hash_map* variables, - Context* context) { +void SetPrimitiveVariables(const FieldDescriptor* descriptor, + int messageBitIndex, int builderBitIndex, + const FieldGeneratorInfo* info, + ClassNameResolver* name_resolver, + std::map* variables, + Context* context) { SetCommonFieldVariables(descriptor, info, variables); (*variables)["empty_list"] = diff --git a/src/google/protobuf/compiler/java/string_field_lite.h b/src/google/protobuf/compiler/java/string_field_lite.h index f0894fb510..f35da288f9 100644 --- a/src/google/protobuf/compiler/java/string_field_lite.h +++ b/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 variables_; + std::map variables_; const int messageBitIndex_; ClassNameResolver* name_resolver_; Context* context_; @@ -133,7 +133,7 @@ class RepeatedImmutableStringFieldLiteGenerator private: const FieldDescriptor* descriptor_; - absl::flat_hash_map variables_; + std::map variables_; ClassNameResolver* name_resolver_; Context* context_; }; diff --git a/src/google/protobuf/compiler/objectivec/enum_field.cc b/src/google/protobuf/compiler/objectivec/enum_field.cc index 4b6e2fe7d5..cf0a3df498 100644 --- a/src/google/protobuf/compiler/objectivec/enum_field.cc +++ b/src/google/protobuf/compiler/objectivec/enum_field.cc @@ -34,7 +34,6 @@ #include #include -#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( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables) { +void SetEnumVariables(const FieldDescriptor* descriptor, + std::map* 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 diff --git a/src/google/protobuf/compiler/objectivec/extension.cc b/src/google/protobuf/compiler/objectivec/extension.cc index 38371e5ed4..91f008ec61 100644 --- a/src/google/protobuf/compiler/objectivec/extension.cc +++ b/src/google/protobuf/compiler/objectivec/extension.cc @@ -37,7 +37,6 @@ #include #include -#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 vars; + std::map 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 vars; + std::map 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); diff --git a/src/google/protobuf/compiler/objectivec/field.cc b/src/google/protobuf/compiler/objectivec/field.cc index 6e73e8dbb8..6274b9d05e 100644 --- a/src/google/protobuf/compiler/objectivec/field.cc +++ b/src/google/protobuf/compiler/objectivec/field.cc @@ -37,7 +37,6 @@ #include #include -#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( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables) { +void SetCommonFieldVariables(const FieldDescriptor* descriptor, + std::map* variables) { std::string camel_case_name = FieldName(descriptor); std::string raw_field_name; if (descriptor->type() == FieldDescriptor::TYPE_GROUP) { diff --git a/src/google/protobuf/compiler/objectivec/field.h b/src/google/protobuf/compiler/objectivec/field.h index 07dc14ea6b..07643720ec 100644 --- a/src/google/protobuf/compiler/objectivec/field.h +++ b/src/google/protobuf/compiler/objectivec/field.h @@ -37,7 +37,6 @@ #include #include -#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 variables_; + std::map variables_; }; class SingleFieldGenerator : public FieldGenerator { diff --git a/src/google/protobuf/compiler/objectivec/file.cc b/src/google/protobuf/compiler/objectivec/file.cc index 95f6d156c2..fd7b644579 100644 --- a/src/google/protobuf/compiler/objectivec/file.cc +++ b/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 vars; + std::map vars; vars["root_class_name"] = root_class_name_; vars["package"] = file_->package(); vars["objc_prefix"] = FileClassPrefix(file_); diff --git a/src/google/protobuf/compiler/objectivec/import_writer.cc b/src/google/protobuf/compiler/objectivec/import_writer.cc index 563f5dedf1..b276ea5634 100644 --- a/src/google/protobuf/compiler/objectivec/import_writer.cc +++ b/src/google/protobuf/compiler/objectivec/import_writer.cc @@ -36,7 +36,6 @@ #include #include -#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* - inout_proto_file_to_framework_name) + std::map* 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* map_; + std::map* 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::iterator existing_entry = + std::map::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::iterator proto_lookup = + std::map::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( diff --git a/src/google/protobuf/compiler/objectivec/import_writer.h b/src/google/protobuf/compiler/objectivec/import_writer.h index d36fe34cb2..f3fb63b4b7 100644 --- a/src/google/protobuf/compiler/objectivec/import_writer.h +++ b/src/google/protobuf/compiler/objectivec/import_writer.h @@ -35,7 +35,6 @@ #include #include -#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 proto_file_to_framework_name_; + std::map proto_file_to_framework_name_; bool need_to_parse_mapping_file_; std::vector protobuf_imports_; diff --git a/src/google/protobuf/compiler/objectivec/message.cc b/src/google/protobuf/compiler/objectivec/message.cc index 19a24c45a7..49375713ee 100644 --- a/src/google/protobuf/compiler/objectivec/message.cc +++ b/src/google/protobuf/compiler/objectivec/message.cc @@ -39,7 +39,6 @@ #include #include -#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 vars; + std::map vars; vars["classname"] = class_name_; vars["rootclassname"] = root_classname_; vars["fields"] = has_fields ? "fields" : "NULL"; diff --git a/src/google/protobuf/compiler/objectivec/message_field.cc b/src/google/protobuf/compiler/objectivec/message_field.cc index 5c695cd3cc..1f174f6ea4 100644 --- a/src/google/protobuf/compiler/objectivec/message_field.cc +++ b/src/google/protobuf/compiler/objectivec/message_field.cc @@ -34,7 +34,6 @@ #include #include -#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( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables) { +void SetMessageVariables(const FieldDescriptor* descriptor, + std::map* variables) { const std::string& message_type = ClassName(descriptor->message_type()); const std::string& containing_class = ClassName(descriptor->containing_type()); diff --git a/src/google/protobuf/compiler/objectivec/names.cc b/src/google/protobuf/compiler/objectivec/names.cc index 702da78434..a82f8b2818 100644 --- a/src/google/protobuf/compiler/objectivec/names.cc +++ b/src/google/protobuf/compiler/objectivec/names.cc @@ -41,7 +41,6 @@ #include #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, - absl::flat_hash_map* - inout_package_to_prefix_map) + PackageToPrefixesCollector( + const std::string& usage, + std::map* 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* prefix_map_; + std::map* prefix_map_; }; class PrefixModeStorage { @@ -130,7 +129,7 @@ class PrefixModeStorage { private: bool use_package_name_; - absl::flat_hash_map package_to_prefix_map_; + std::map 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::const_iterator prefix_lookup = + std::map::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( - const std::string& expected_prefixes_path, - absl::flat_hash_map* prefix_map, - std::string* out_error) { +bool LoadExpectedPackagePrefixes(const std::string& expected_prefixes_path, + std::map* prefix_map, + 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& - expected_package_prefixes, + const std::map& 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::const_iterator package_match = + std::map::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::const_iterator i = + for (std::map::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& files, } // Load the expected package prefixes, if available, to validate against. - absl::flat_hash_map expected_package_prefixes; + std::map expected_package_prefixes; if (!LoadExpectedPackagePrefixes(validation_options.expected_prefixes_path, &expected_package_prefixes, out_error)) { return false; diff --git a/src/google/protobuf/compiler/objectivec/oneof.h b/src/google/protobuf/compiler/objectivec/oneof.h index a35a2f6ba0..ea79251613 100644 --- a/src/google/protobuf/compiler/objectivec/oneof.h +++ b/src/google/protobuf/compiler/objectivec/oneof.h @@ -36,7 +36,6 @@ #include #include -#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 variables_; + std::map variables_; }; } // namespace objectivec diff --git a/src/google/protobuf/compiler/objectivec/primitive_field.cc b/src/google/protobuf/compiler/objectivec/primitive_field.cc index 45eeb0a520..d116ec0462 100644 --- a/src/google/protobuf/compiler/objectivec/primitive_field.cc +++ b/src/google/protobuf/compiler/objectivec/primitive_field.cc @@ -33,7 +33,6 @@ #include #include -#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( - const FieldDescriptor* descriptor, - absl::flat_hash_map* variables) { +void SetPrimitiveVariables(const FieldDescriptor* descriptor, + std::map* variables) { std::string primitive_name = PrimitiveTypeName(descriptor); (*variables)["type"] = primitive_name; (*variables)["storage_type"] = primitive_name; diff --git a/src/google/protobuf/compiler/python/generator.cc b/src/google/protobuf/compiler/python/generator.cc index 1475267337..0f51a7d2a3 100644 --- a/src/google/protobuf/compiler/python/generator.cc +++ b/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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map 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 m; + std::map m; m["name"] = field.name(); m["full_name"] = field.full_name(); m["index"] = absl::StrCat(field.index()); diff --git a/src/google/protobuf/compiler/python/pyi_generator.h b/src/google/protobuf/compiler/python/pyi_generator.h index 8a32a98481..7f1e5d839d 100644 --- a/src/google/protobuf/compiler/python/pyi_generator.h +++ b/src/google/protobuf/compiler/python/pyi_generator.h @@ -39,7 +39,6 @@ #include #include -#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 import_map_; + mutable std::map import_map_; }; } // namespace python diff --git a/src/google/protobuf/io/printer.h b/src/google/protobuf/io/printer.h index 68d58f0823..450e90ffc8 100644 --- a/src/google/protobuf/io/printer.h +++ b/src/google/protobuf/io/printer.h @@ -40,6 +40,7 @@ #include #include #include +#include #include #include #include @@ -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 + template 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 StringType = absl::string_view, std::enable_if_t::value, int> = 0> auto WithVars(Map&& vars) { var_lookups_.emplace_back([vars = std::forward(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 + template auto WithAnnotations(const Map* vars) { annotation_lookups_.emplace_back( [vars](absl::string_view var) -> absl::optional { - 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(vars)]( absl::string_view var) -> absl::optional { - 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& 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::string>(&vars); - PrintImpl(text, {}, opts); - } - template 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 map; + absl::flat_hash_map 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 args, - const absl::flat_hash_map& vars, + const std::map& vars, absl::string_view format) { PrintOptions opts; opts.use_curly_brace_substitutions = true; diff --git a/third_party/utf8_range b/third_party/utf8_range index 45fbf543fe..a67b76f9f4 160000 --- a/third_party/utf8_range +++ b/third_party/utf8_range @@ -1 +1 @@ -Subproject commit 45fbf543fec00020a08650791a37575319a3ea1d +Subproject commit a67b76f9f40107f2c78a5aa860bb6ce37ed83d85