Add native Abseil flag support to protobuf message types.

Now protobuf messages can be used with ABSL_FLAG declarations.
It uses the text format representation.

PiperOrigin-RevId: 867760218

Author: sbenzaquen

src/google/protobuf/BUILD.bazel

@@ -1145,9 +1145,11 @@ filegroup(
 
 filegroup(
     name = "test_proto_all_srcs",
+    testonly = 1,
     srcs = [
         ":test_proto_editions_srcs",
         ":test_proto_srcs",
+        "//src/google/protobuf/test_protos:test_proto_srcs",
     ],
     visibility = ["//:__subpackages__"],
 )
@@ -2152,15 +2154,19 @@ cc_test(
         "//src/google/protobuf/io",
         "//src/google/protobuf/io:io_win32",
         "//src/google/protobuf/stubs",
+        "//src/google/protobuf/test_protos:test_cc_protos",
         "//src/google/protobuf/testing",
         "//src/google/protobuf/testing:file",
         "//src/google/protobuf/util:differencer",
         "@abseil-cpp//absl/base:config",
+        "@abseil-cpp//absl/flags:flag",
+        "@abseil-cpp//absl/flags:marshalling",
         "@abseil-cpp//absl/hash:hash_testing",
         "@abseil-cpp//absl/log:absl_check",
         "@abseil-cpp//absl/log:scoped_mock_log",
         "@abseil-cpp//absl/strings",
         "@abseil-cpp//absl/strings:cord",
+        "@abseil-cpp//absl/strings:str_format",
         "@googletest//:gtest",
         "@googletest//:gtest_main",
     ],

src/google/protobuf/message.cc

@@ -14,20 +14,30 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <initializer_list>
 #include <new>  // IWYU pragma: keep for operator new().
 #include <queue>
 #include <string>
+#include <utility>
+#include <variant>
 #include <vector>
 
+#include "absl/algorithm/container.h"
 #include "absl/base/call_once.h"
 #include "absl/base/optimization.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/hash/hash.h"
 #include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/types/optional.h"
 #include "google/protobuf/descriptor.h"
@@ -37,13 +47,15 @@
 #include "google/protobuf/generated_message_tctable_impl.h"
 #include "google/protobuf/generated_message_util.h"
 #include "google/protobuf/io/coded_stream.h"
+#include "google/protobuf/io/tokenizer.h"
 #include "google/protobuf/map_field.h"
 #include "google/protobuf/message_lite.h"
 #include "google/protobuf/parse_context.h"
 #include "google/protobuf/port.h"
 #include "google/protobuf/reflection_internal.h"
 #include "google/protobuf/reflection_ops.h"
 #include "google/protobuf/reflection_visit_fields.h"
+#include "google/protobuf/text_format.h"
 #include "google/protobuf/unknown_field_set.h"
 #include "google/protobuf/wire_format.h"
 
@@ -124,6 +136,205 @@ PROTOBUF_CONSTINIT PROTOBUF_EXPORT const DescriptorMethods
 using internal::ReflectionOps;
 using internal::WireFormat;
 
+namespace {
+
+enum class AbslFlagFormat {
+  kTextFormat,
+  kSerialized,
+};
+
+struct AbslFlagHeader {
+  AbslFlagFormat format;
+  absl::string_view format_name;
+  std::vector<absl::string_view> options;
+  bool uses_dead_char = false;
+  bool uses_prefix = false;
+};
+
+std::variant<AbslFlagHeader, std::string> ConsumeAbslFlagHeader(
+    absl::string_view& text) {
+  AbslFlagHeader header;
+
+  if (text.empty()) {
+    // Whatever format is fine.
+    header.format = AbslFlagFormat::kTextFormat;
+    return header;
+  }
+
+  if (absl::ConsumePrefix(&text, ":")) {
+    header.uses_dead_char = true;
+  }
+
+  auto pos = text.find(':');
+  if (pos == text.npos) {
+    header.format = AbslFlagFormat::kTextFormat;
+    return header;
+  }
+
+  header.uses_prefix = true;
+
+  absl::string_view format_spec = text.substr(0, pos);
+  if (!header.uses_dead_char) {
+    header.format_name = format_spec;
+    // Legacy specs.
+    if (format_spec == "text") {
+      header.format = AbslFlagFormat::kTextFormat;
+    } else if (format_spec == "base64text") {
+      header.format = AbslFlagFormat::kTextFormat;
+      header.options = {"base64"};
+    } else if (format_spec == "base64serialized") {
+      header.format = AbslFlagFormat::kSerialized;
+      header.options = {"base64"};
+    } else {
+      if (absl::StrContains(format_spec, ",")) {
+        return absl::StrFormat(
+            "Format options are only allowed with delimited format specifier. "
+            "Use `:%1$s:` instead of `%1$s:`",
+            format_spec);
+      }
+      header.uses_prefix = false;
+      header.format = AbslFlagFormat::kTextFormat;
+      return header;
+    }
+  } else {
+    std::vector<absl::string_view> parts = absl::StrSplit(format_spec, ',');
+    header.format_name = parts[0];
+
+    if (header.format_name == "text") {
+      header.format = AbslFlagFormat::kTextFormat;
+    } else if (header.format_name == "serialized") {
+      header.format = AbslFlagFormat::kSerialized;
+    } else {
+      return absl::StrFormat("Invalid format `%s`.", header.format_name);
+    }
+
+    header.options.assign(parts.begin() + 1, parts.end());
+  }
+
+  if (header.uses_prefix) {
+    text.remove_prefix(pos + 1);
+  }
+  return header;
+}
+
+}  // namespace
+
+bool Message::AbslParseFlagImpl(absl::string_view text, std::string& error) {
+  Clear();
+
+  auto header_or_error = ConsumeAbslFlagHeader(text);
+  if (std::holds_alternative<std::string>(header_or_error)) {
+    error = std::get<std::string>(header_or_error);
+    return false;
+  }
+  auto header = std::get<AbslFlagHeader>(std::move(header_or_error));
+
+  if (!header.uses_dead_char) {
+    error = "Prefix must start with a `:`. Eg `:text:`.";
+    return false;
+  }
+
+  // If we have a prefix without a dead char, verify that the message does not
+  // have a field by that name as that would be ambiguous.
+  if (!header.uses_dead_char && header.uses_prefix &&
+      GetDescriptor()->FindFieldByName(header.format_name) != nullptr) {
+    error = absl::StrFormat(
+        "Prefix `%s:` used is ambiguous with message fields. If you meant to "
+        "use this prefix, use `:%s:` instead. If you meant to use text "
+        "format, use `:text:` as a prefix.",
+        header.format_name, header.format_name);
+    return false;
+  }
+
+  const auto verify_options =
+      [&](std::initializer_list<absl::string_view> valid_options) -> bool {
+    for (absl::string_view o : header.options) {
+      if (!absl::c_linear_search(valid_options, o)) {
+        error = absl::StrFormat("Unknown option `%s` for format `%s`.", o,
+                                header.format_name);
+        return false;
+      }
+    }
+    return true;
+  };
+
+  static constexpr absl::string_view kBase64 = "base64";
+
+  std::string unescaped;
+  const auto unescape_if_needed = [&] {
+    if (absl::c_linear_search(header.options, kBase64)) {
+      if (!absl::Base64Unescape(text, &unescaped)) {
+        error = absl::StrFormat("Invalid base64 input.");
+        return false;
+      }
+      text = unescaped;
+    }
+    return true;
+  };
+
+  switch (header.format) {
+    case AbslFlagFormat::kTextFormat: {
+      static constexpr absl::string_view kIgnoreUnknown = "ignore_unknown";
+      if (!verify_options({kIgnoreUnknown, kBase64})) return false;
+      if (!unescape_if_needed()) return false;
+      TextFormat::Parser parser;
+      struct StringErrorCollector : io::ErrorCollector {
+        explicit StringErrorCollector(std::string& error) : error(error) {}
+        std::string& error;
+        void RecordError(int line, io::ColumnNumber column,
+                         absl::string_view message) override {
+          error = absl::StrFormat("(Line %v, Column %v): %v", line, column,
+                                  message);
+        }
+      } collector(error);
+      if (absl::c_linear_search(header.options, kIgnoreUnknown)) {
+        parser.AllowUnknownField(true);
+        parser.AllowUnknownExtension(true);
+      }
+      parser.RecordErrorsTo(&collector);
+      return parser.ParseFromString(text, this);
+    }
+
+    case AbslFlagFormat::kSerialized: {
+      if (!verify_options({kBase64})) return false;
+      if (!unescape_if_needed()) return false;
+      return ParseFromString(text);
+    }
+
+    default:
+      internal::Unreachable();
+  }
+}
+
+std::string Message::AbslUnparseFlagImpl() const {
+  bool has_ufs = !GetReflection()->GetUnknownFields(*this).empty();
+  internal::VisitMessageFields(*this, [&](const auto& msg) {
+    has_ufs = has_ufs || !msg.GetReflection()->GetUnknownFields(msg).empty();
+  });
+
+  if (has_ufs) {
+    // We can't use text format because it won't round trip
+    // Use binary instead.
+    return absl::StrCat(":serialized,base64:",
+                        absl::Base64Escape(SerializeAsString()));
+  } else {
+    TextFormat::Printer printer;
+    printer.SetSingleLineMode(true);
+    printer.SetUseShortRepeatedPrimitives(true);
+    std::string str;
+    // PrintToString can't really fail.
+    (void)printer.PrintToString(*this, &str);
+
+    // If completely empty, just return the empty string.
+    // It is usually the default and nicer to read.
+    if (str.empty()) {
+      return str;
+    }
+
+    return absl::StrCat(":text:", str);
+  }
+}
+
 void Message::MergeImpl(MessageLite& to, const MessageLite& from) {
   ReflectionOps::Merge(DownCastMessage<Message>(from),
                        DownCastMessage<Message>(&to));

src/google/protobuf/message.h

@@ -388,6 +388,33 @@ class PROTOBUF_EXPORT Message : public MessageLite {
     return GetMetadata().reflection;
   }
 
+  // Abseil flag support for Messages.
+  //
+  // Flag syntax is `:format,options...:value` where:
+  //  - `format` is one of `text`, `serialized`.
+  //  - `options` is a possibly empty list of options. Each format has its
+  //    supported options.
+  //  - `value` is the payload in the specified format.
+  //
+  //  The valid options are:
+  //
+  //   * For `text`:
+  //     - `base64`: indicates that `value` is encoded as base64.
+  //     - `ignore_unknown`: when specified, unknown field/extensions are
+  //       dropped. Otherwise, they cause a parse failure.
+  //
+  //   * For `serialized`:
+  //     - `base64`: indicates that `value` is encoded as base64. It is
+  //       recommended to use `serialized` with `base64` given that passing
+  //       binary data in shells is difficult and error prone.
+  friend bool AbslParseFlag(absl::string_view text, Message* msg,
+                            std::string* error) {
+    return msg->AbslParseFlagImpl(text, *error);
+  }
+  friend std::string AbslUnparseFlag(const Message& msg) {
+    return msg.AbslUnparseFlagImpl();
+  }
+
  protected:
 #if !defined(PROTOBUF_CUSTOM_VTABLE)
   constexpr Message() {}
@@ -402,6 +429,9 @@ class PROTOBUF_EXPORT Message : public MessageLite {
   // For CODE_SIZE types
   static bool IsInitializedImpl(const MessageLite&);
 
+  bool AbslParseFlagImpl(absl::string_view text, std::string& error);
+  std::string AbslUnparseFlagImpl() const;
+
   size_t ComputeUnknownFieldsSize(
       size_t total_size, const internal::CachedSize* cached_size) const;
   size_t MaybeComputeUnknownFieldsSize(

src/google/protobuf/message_unittest.cc

@@ -16,13 +16,17 @@
 #include <memory>
 #include <string>
 #include <tuple>
+#include <variant>
 #include <vector>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include "absl/flags/marshalling.h"
 #include "absl/hash/hash_testing.h"
 #include "absl/log/absl_check.h"
+#include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/arena.h"
 #include "google/protobuf/dynamic_message.h"
@@ -32,6 +36,7 @@
 #include "google/protobuf/internal_visibility.h"
 #include "google/protobuf/message_lite.h"
 #include "google/protobuf/port.h"
+#include "google/protobuf/test_protos/abseil_flag_test.pb.h"
 #include "google/protobuf/unittest.pb.h"
 #include "google/protobuf/unittest_import.pb.h"
 #include "google/protobuf/unittest_lite.pb.h"

src/google/protobuf/test_protos/BUILD

@@ -0,0 +1,25 @@
+load("//bazel:cc_proto_library.bzl", "cc_proto_library")
+load("//bazel:proto_library.bzl", "proto_library")
+
+package(
+    default_applicable_licenses = ["//:license"],
+    default_testonly = 1,
+    default_visibility = ["//src/google/protobuf:__subpackages__"],
+)
+
+proto_library(
+    name = "test_protos",
+    srcs = glob(["*.proto"]),
+    strip_import_prefix = "/src",
+)
+
+cc_proto_library(
+    name = "test_cc_protos",
+    deps = [":test_protos"],
+)
+
+filegroup(
+    name = "test_proto_srcs",
+    srcs = glob(["*.proto"]),
+    visibility = ["//:__subpackages__"],
+)