Update cpp-protobuf to 22.5

Привет!\
Этот PR переключат cpp & python библиотеки protobuf на версию 22.5

Если у вас возникли проблемы после влития этого PR:

1. Если начали падать канон тесты, то проведите их переканонизацию

2. Прочитайте <https://wiki.yandex-team.ru/users/nechda/obnovlenie-cpp-protobuf-22.5/> страничку с основными изменениями

3. Если страничка в вики не помогла, то пишите в [DEVTOOLSSUPPORT](https://st.yandex-team.ru/DEVTOOLSSUPPORT)
7fecade616c20a841b9e9af7b7998bdfc8d2807d

1 files changed, 156 insertions, 108 deletions

diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/generator.cc b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/generator.cc
index 0da2027a1e6..6187b72cbab 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/generator.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/generator.cc
@@ -32,31 +32,68 @@
 //  Based on original Protocol Buffers design by
 //  Sanjay Ghemawat, Jeff Dean, and others.
 
-#include <google/protobuf/compiler/cpp/generator.h>
+#include "google/protobuf/compiler/cpp/generator.h"
 
+#include <cstdlib>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include <google/protobuf/stubs/strutil.h>
-#include <google/protobuf/io/printer.h>
-#include <google/protobuf/io/zero_copy_stream.h>
-#include <google/protobuf/compiler/cpp/file.h>
-#include <google/protobuf/compiler/cpp/helpers.h>
-#include <google/protobuf/descriptor.pb.h>
+#include "y_absl/strings/match.h"
+#include "y_absl/strings/str_cat.h"
+#include "y_absl/strings/string_view.h"
+#include "google/protobuf/compiler/cpp/file.h"
+#include "google/protobuf/compiler/cpp/helpers.h"
+#include "google/protobuf/descriptor.pb.h"
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace cpp {
+namespace {
+TProtoStringType NumberedCcFileName(y_absl::string_view basename, int number) {
+  return y_absl::StrCat(basename, ".out/", number, ".cc");
+}
 
-CppGenerator::CppGenerator() {}
-CppGenerator::~CppGenerator() {}
+y_absl::flat_hash_map<y_absl::string_view, TProtoStringType> CommonVars(
+    const Options& options) {
+  bool is_oss = options.opensource_runtime;
+  return {
+      {"proto_ns", ProtobufNamespace(options)},
+      {"pb", y_absl::StrCat("::", ProtobufNamespace(options))},
+      {"pbi", y_absl::StrCat("::", ProtobufNamespace(options), "::internal")},
 
-namespace {
-TProtoStringType NumberedCcFileName(const TProtoStringType& basename, int number) {
-  return StrCat(basename, ".out/", number, ".cc");
+      {"string", "TProtoStringType"},
+      {"int8", "::int8_t"},
+      {"int32", "::arc_i32"},
+      {"int64", "::arc_i64"},
+      {"uint8", "::uint8_t"},
+      {"uint32", "::arc_ui32"},
+      {"uint64", "::arc_ui64"},
+
+      {"hrule_thick", kThickSeparator},
+      {"hrule_thin", kThinSeparator},
+
+      // Warning: there is some clever naming/splitting here to avoid extract
+      // script rewrites.  The names of these variables must not be things that
+      // the extract script will rewrite.  That's why we use "CHK" (for example)
+      // instead of "Y_ABSL_CHECK".
+      //
+      // These values are things the extract script would rewrite if we did not
+      // split them.  It might not strictly matter since we don't generate
+      // google3 code in open-source.  But it's good to prevent surprising
+      // things from happening.
+      {"GOOGLE_PROTOBUF", is_oss ? "GOOGLE_PROTOBUF"
+                                 : "GOOGLE3_PROTOBU"
+                                   "F"},
+      {"CHK",
+       "Y_ABSL_CHEC"
+       "K"},
+      {"DCHK",
+       "Y_ABSL_DCHEC"
+       "K"},
+  };
 }
 }  // namespace
 
@@ -64,7 +101,7 @@ bool CppGenerator::Generate(const FileDescriptor* file,
                             const TProtoStringType& parameter,
                             GeneratorContext* generator_context,
                             TProtoStringType* error) const {
-  std::vector<std::pair<TProtoStringType, TProtoStringType> > options;
+  std::vector<std::pair<TProtoStringType, TProtoStringType>> options;
   ParseGeneratorParameter(parameter, &options);
 
   // -----------------------------------------------------------------
@@ -93,72 +130,69 @@ bool CppGenerator::Generate(const FileDescriptor* file,
   file_options.opensource_runtime = opensource_runtime_;
   file_options.runtime_include_base = runtime_include_base_;
 
-  for (int i = 0; i < options.size(); i++) {
-    if (options[i].first == "dllexport_decl") {
-      file_options.dllexport_decl = options[i].second;
-    } else if (options[i].first == "safe_boundary_check") {
+  for (const auto& option : options) {
+    const auto& key = option.first;
+    const auto& value = option.second;
+
+    if (key == "dllexport_decl") {
+      file_options.dllexport_decl = value;
+    } else if (key == "safe_boundary_check") {
       file_options.safe_boundary_check = true;
-    } else if (options[i].first == "annotate_headers") {
+    } else if (key == "annotate_headers") {
       file_options.annotate_headers = true;
-    } else if (options[i].first == "annotation_pragma_name") {
-      file_options.annotation_pragma_name = options[i].second;
-    } else if (options[i].first == "annotation_guard_name") {
-      file_options.annotation_guard_name = options[i].second;
-    } else if (options[i].first == "speed") {
+    } else if (key == "annotation_pragma_name") {
+      file_options.annotation_pragma_name = value;
+    } else if (key == "annotation_guard_name") {
+      file_options.annotation_guard_name = value;
+    } else if (key == "speed") {
       file_options.enforce_mode = EnforceOptimizeMode::kSpeed;
-    } else if (options[i].first == "code_size") {
+    } else if (key == "code_size") {
       file_options.enforce_mode = EnforceOptimizeMode::kCodeSize;
-    } else if (options[i].first == "lite") {
+    } else if (key == "lite") {
       file_options.enforce_mode = EnforceOptimizeMode::kLiteRuntime;
-    } else if (options[i].first == "lite_implicit_weak_fields") {
+    } else if (key == "lite_implicit_weak_fields") {
       file_options.enforce_mode = EnforceOptimizeMode::kLiteRuntime;
       file_options.lite_implicit_weak_fields = true;
-      if (!options[i].second.empty()) {
-        file_options.num_cc_files =
-            strto32(options[i].second.c_str(), nullptr, 10);
+      if (!value.empty()) {
+        file_options.num_cc_files = std::strtol(value.c_str(), nullptr, 10);
       }
-    } else if (options[i].first == "proto_h") {
+    } else if (key == "proto_h") {
       file_options.proto_h = true;
-    } else if (options[i].first == "annotate_accessor") {
+    } else if (key == "proto_static_reflection_h") {
+    } else if (key == "annotate_accessor") {
       file_options.annotate_accessor = true;
-    } else if (options[i].first == "inject_field_listener_events") {
+    } else if (key == "inject_field_listener_events") {
       file_options.field_listener_options.inject_field_listener_events = true;
-    } else if (options[i].first == "forbidden_field_listener_events") {
+    } else if (key == "forbidden_field_listener_events") {
       std::size_t pos = 0;
       do {
-        std::size_t next_pos = options[i].second.find_first_of("+", pos);
+        std::size_t next_pos = value.find_first_of("+", pos);
         if (next_pos == TProtoStringType::npos) {
-          next_pos = options[i].second.size();
+          next_pos = value.size();
         }
         if (next_pos > pos)
           file_options.field_listener_options.forbidden_field_listener_events
-              .insert(options[i].second.substr(pos, next_pos - pos));
+              .emplace(value.substr(pos, next_pos - pos));
         pos = next_pos + 1;
-      } while (pos < options[i].second.size());
-    } else if (options[i].first == "verified_lazy") {
-      file_options.unverified_lazy = false;
-    } else if (options[i].first == "unverified_lazy_message_sets") {
+      } while (pos < value.size());
+    } else if (key == "unverified_lazy_message_sets") {
       file_options.unverified_lazy_message_sets = true;
-    } else if (options[i].first == "message_owned_arena_trial") {
-      file_options.message_owned_arena_trial = true;
-    } else if (options[i].first == "force_eagerly_verified_lazy") {
+    } else if (key == "force_eagerly_verified_lazy") {
       file_options.force_eagerly_verified_lazy = true;
-    } else if (options[i].first == "experimental_tail_call_table_mode") {
-      if (options[i].second == "never") {
+    } else if (key == "experimental_tail_call_table_mode") {
+      if (value == "never") {
         file_options.tctable_mode = Options::kTCTableNever;
-      } else if (options[i].second == "guarded") {
+      } else if (value == "guarded") {
         file_options.tctable_mode = Options::kTCTableGuarded;
-      } else if (options[i].second == "always") {
+      } else if (value == "always") {
         file_options.tctable_mode = Options::kTCTableAlways;
       } else {
-        *error = "Unknown value for experimental_tail_call_table_mode: " +
-                 options[i].second;
+        *error = y_absl::StrCat(
+            "Unknown value for experimental_tail_call_table_mode: ", value);
         return false;
       }
-    } else if (options[i].first == "transitive_pb_h") {
-      file_options.transitive_pb_h = options[i].second != "false";
     } else {
-      *error = "Unknown generator option: " + options[i].first;
+      *error = y_absl::StrCat("Unknown generator option: ", key);
       return false;
     }
   }
@@ -176,6 +210,17 @@ bool CppGenerator::Generate(const FileDescriptor* file,
 
   TProtoStringType basename = StripProto(file->name());
 
+  auto generate_reserved_static_reflection_header = [&basename,
+                                                     &generator_context]() {
+    auto output = y_absl::WrapUnique(generator_context->Open(
+        y_absl::StrCat(basename, ".proto.static_reflection.h")));
+    io::Printer(output.get()).Emit(R"cc(
+      // Reserved for future use.
+    )cc");
+  };
+  // Suppress maybe unused warning.
+  (void)generate_reserved_static_reflection_header;
+
   if (MaybeBootstrap(file_options, generator_context, file_options.bootstrap,
                      &basename)) {
     return true;
@@ -185,58 +230,51 @@ bool CppGenerator::Generate(const FileDescriptor* file,
 
   // Generate header(s).
   if (file_options.proto_h) {
-    std::unique_ptr<io::ZeroCopyOutputStream> output(
-        generator_context->Open(basename + ".proto.h"));
+    auto output = y_absl::WrapUnique(
+        generator_context->Open(y_absl::StrCat(basename, ".proto.h")));
+
     GeneratedCodeInfo annotations;
     io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
         &annotations);
-    TProtoStringType info_path = basename + ".proto.h.meta";
-    io::Printer printer(
-        output.get(), '$',
-        file_options.annotate_headers ? &annotation_collector : nullptr);
+    io::Printer::Options options;
+    if (file_options.annotate_headers) {
+      options.annotation_collector = &annotation_collector;
+    }
+
+    io::Printer p(output.get(), options);
+    auto v = p.WithVars(CommonVars(file_options));
+
+    TProtoStringType info_path = y_absl::StrCat(basename, ".proto.h.meta");
     file_generator.GenerateProtoHeader(
-        &printer, file_options.annotate_headers ? info_path : "");
+        &p, file_options.annotate_headers ? info_path : "");
+
     if (file_options.annotate_headers) {
-      std::unique_ptr<io::ZeroCopyOutputStream> info_output(
-          generator_context->Open(info_path));
+      auto info_output = y_absl::WrapUnique(generator_context->Open(info_path));
       annotations.SerializeToZeroCopyStream(info_output.get());
     }
   }
 
   {
-    std::unique_ptr<io::ZeroCopyOutputStream> output(
-        generator_context->Open(basename + ".pb.h"));
+    auto output = y_absl::WrapUnique(
+        generator_context->Open(y_absl::StrCat(basename, ".pb.h")));
+
     GeneratedCodeInfo annotations;
     io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
         &annotations);
-    TProtoStringType info_path = basename + ".pb.h.meta";
-    io::Printer printer(
-        output.get(), '$',
-        file_options.annotate_headers ? &annotation_collector : nullptr);
-    file_generator.GeneratePBHeader(
-        &printer, file_options.annotate_headers ? info_path : "");
+    io::Printer::Options options;
     if (file_options.annotate_headers) {
-      std::unique_ptr<io::ZeroCopyOutputStream> info_output(
-          generator_context->Open(info_path));
-      annotations.SerializeToZeroCopyStream(info_output.get());
+      options.annotation_collector = &annotation_collector;
     }
-  }
 
-  if (!file_options.transitive_pb_h) {
-    std::unique_ptr<io::ZeroCopyOutputStream> output(
-        generator_context->Open(basename + ".deps.pb.h"));
-    GeneratedCodeInfo annotations;
-    io::AnnotationProtoCollector<GeneratedCodeInfo> annotation_collector(
-        &annotations);
-    TProtoStringType info_path = basename + ".deps.pb.h.meta";
-    io::Printer printer(
-        output.get(), '$',
-        file_options.annotate_headers ? &annotation_collector : NULL);
-    file_generator.GeneratePBDeps(
-        &printer, file_options.annotate_headers ? info_path : "");
+    io::Printer p(output.get(), options);
+    auto v = p.WithVars(CommonVars(file_options));
+
+    TProtoStringType info_path = y_absl::StrCat(basename, ".pb.h.meta");
+    file_generator.GeneratePBHeader(
+        &p, file_options.annotate_headers ? info_path : "");
+
     if (file_options.annotate_headers) {
-      std::unique_ptr<io::ZeroCopyOutputStream> info_output(
-          generator_context->Open(info_path));
+      auto info_output = y_absl::WrapUnique(generator_context->Open(info_path));
       annotations.SerializeToZeroCopyStream(info_output.get());
     }
   }
@@ -246,10 +284,12 @@ bool CppGenerator::Generate(const FileDescriptor* file,
     {
       // This is the global .cc file, containing
       // enum/services/tables/reflection
-      std::unique_ptr<io::ZeroCopyOutputStream> output(
-          generator_context->Open(basename + ".pb.cc"));
-      io::Printer printer(output.get(), '$');
-      file_generator.GenerateGlobalSource(&printer);
+      auto output = y_absl::WrapUnique(
+          generator_context->Open(y_absl::StrCat(basename, ".pb.cc")));
+      io::Printer p(output.get());
+      auto v = p.WithVars(CommonVars(file_options));
+
+      file_generator.GenerateGlobalSource(&p);
     }
 
     int num_cc_files =
@@ -260,40 +300,48 @@ bool CppGenerator::Generate(const FileDescriptor* file,
     // pb.cc file. If we have more files than messages, then some files will
     // be generated as empty placeholders.
     if (file_options.num_cc_files > 0) {
-      GOOGLE_CHECK_LE(num_cc_files, file_options.num_cc_files)
+      Y_ABSL_CHECK_LE(num_cc_files, file_options.num_cc_files)
           << "There must be at least as many numbered .cc files as messages "
              "and extensions.";
       num_cc_files = file_options.num_cc_files;
     }
+
     int cc_file_number = 0;
-    for (int i = 0; i < file_generator.NumMessages(); i++) {
-      std::unique_ptr<io::ZeroCopyOutputStream> output(generator_context->Open(
+    for (int i = 0; i < file_generator.NumMessages(); ++i) {
+      auto output = y_absl::WrapUnique(generator_context->Open(
           NumberedCcFileName(basename, cc_file_number++)));
-      io::Printer printer(output.get(), '$');
-      file_generator.GenerateSourceForMessage(i, &printer);
+      io::Printer p(output.get());
+      auto v = p.WithVars(CommonVars(file_options));
+
+      file_generator.GenerateSourceForMessage(i, &p);
     }
-    for (int i = 0; i < file_generator.NumExtensions(); i++) {
-      std::unique_ptr<io::ZeroCopyOutputStream> output(generator_context->Open(
+
+    for (int i = 0; i < file_generator.NumExtensions(); ++i) {
+      auto output = y_absl::WrapUnique(generator_context->Open(
           NumberedCcFileName(basename, cc_file_number++)));
-      io::Printer printer(output.get(), '$');
-      file_generator.GenerateSourceForExtension(i, &printer);
+      io::Printer p(output.get());
+      auto v = p.WithVars(CommonVars(file_options));
+
+      file_generator.GenerateSourceForExtension(i, &p);
     }
+
     // Create empty placeholder files if necessary to match the expected number
     // of files.
-    for (; cc_file_number < num_cc_files; ++cc_file_number) {
-      std::unique_ptr<io::ZeroCopyOutputStream> output(generator_context->Open(
-          NumberedCcFileName(basename, cc_file_number)));
+    while (cc_file_number < num_cc_files) {
+      (void)y_absl::WrapUnique(generator_context->Open(
+          NumberedCcFileName(basename, cc_file_number++)));
     }
   } else {
-    std::unique_ptr<io::ZeroCopyOutputStream> output(
-        generator_context->Open(basename + ".pb.cc"));
-    io::Printer printer(output.get(), '$');
-    file_generator.GenerateSource(&printer);
+    auto output = y_absl::WrapUnique(
+        generator_context->Open(y_absl::StrCat(basename, ".pb.cc")));
+    io::Printer p(output.get());
+    auto v = p.WithVars(CommonVars(file_options));
+
+    file_generator.GenerateSource(&p);
   }
 
   return true;
 }
-
 }  // namespace cpp
 }  // namespace compiler
 }  // namespace protobuf