protovalidate 0.1.0.beta1

data/ext/protovalidate/sys/third_party/protobuf/src/google/protobuf/text_format.cc

@@ -0,0 +1,3324 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google LLC.  All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
+
+// Author: jschorr@google.com (Joseph Schorr)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+
+#include "google/protobuf/text_format.h"
+
+#include <stdio.h>
+
+#include <algorithm>
+#include <atomic>
+#include <climits>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <random>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/container/btree_set.h"
+#include "absl/log/absl_check.h"
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/charset.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.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/time/clock.h"
+#include "absl/time/time.h"
+#include "google/protobuf/any.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/descriptor.pb.h"
+#include "google/protobuf/dynamic_message.h"
+#include "google/protobuf/internal_visibility.h"
+#include "google/protobuf/io/coded_stream.h"
+#include "google/protobuf/io/strtod.h"
+#include "google/protobuf/io/tokenizer.h"
+#include "google/protobuf/io/zero_copy_stream.h"
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
+#include "google/protobuf/map_field.h"
+#include "google/protobuf/message.h"
+#include "google/protobuf/reflection_mode.h"
+#include "google/protobuf/repeated_field.h"
+#include "google/protobuf/unknown_field_set.h"
+#include "google/protobuf/wire_format_lite.h"
+#include "utf8_validity.h"
+
+// Must be included last.
+#include "google/protobuf/port_def.inc"
+
+namespace google {
+namespace protobuf {
+
+using internal::FieldReporterLevel;
+using internal::ScopedReflectionMode;
+
+namespace {
+
+const absl::string_view kFieldValueReplacement = "[REDACTED]";
+
+inline bool IsHexNumber(const std::string& str) {
+  return (str.length() >= 2 && str[0] == '0' &&
+          (str[1] == 'x' || str[1] == 'X'));
+}
+
+inline bool IsOctNumber(const std::string& str) {
+  return (str.length() >= 2 && str[0] == '0' &&
+          (str[1] >= '0' && str[1] < '8'));
+}
+
+// The number of fields that are redacted in AbslStringify.
+std::atomic<int64_t> num_redacted_field{0};
+
+inline void IncrementRedactedFieldCounter() {
+  num_redacted_field.fetch_add(1, std::memory_order_relaxed);
+}
+
+inline void TrimTrailingSpace(std::string& debug_string) {
+  // Single line mode currently might have an extra space at the end.
+  if (!debug_string.empty() && debug_string.back() == ' ') {
+    debug_string.pop_back();
+  }
+}
+
+}  // namespace
+
+namespace internal {
+const char kDebugStringSilentMarker[] = "";
+const char kDebugStringSilentMarkerForDetection[] = "\t ";
+
+int64_t GetRedactedFieldCount() {
+  return num_redacted_field.load(std::memory_order_relaxed);
+}
+
+enum class Option { kNone, kShort, kUTF8 };
+
+std::string StringifyMessage(const Message& message, Option option,
+                             FieldReporterLevel reporter_level) {
+  // Indicate all scoped reflection calls are from DebugString function.
+  ScopedReflectionMode scope(ReflectionMode::kDebugString);
+
+  TextFormat::Printer printer;
+  internal::FieldReporterLevel reporter = reporter_level;
+  switch (option) {
+    case Option::kShort:
+      printer.SetSingleLineMode(true);
+      break;
+    case Option::kUTF8:
+      printer.SetUseUtf8StringEscaping(true);
+      break;
+    case Option::kNone:
+      break;
+  }
+  printer.SetExpandAny(true);
+  printer.SetRedactDebugString(true);
+  printer.SetRandomizeDebugString(true);
+  printer.SetReportSensitiveFields(reporter);
+  std::string result;
+  // TODO: Remove this suppression.
+  (void)printer.PrintToString(message, &result);
+
+  if (option == Option::kShort) {
+    TrimTrailingSpace(result);
+  }
+
+  return result;
+}
+
+PROTOBUF_EXPORT std::string StringifyMessage(const Message& message) {
+  return StringifyMessage(message, Option::kNone,
+                          FieldReporterLevel::kAbslStringify);
+}
+}  // namespace internal
+
+std::string Message::DebugString() const {
+  return internal::StringifyMessage(*this, internal::Option::kNone,
+                                    FieldReporterLevel::kDebugString);
+}
+
+std::string Message::ShortDebugString() const {
+  return internal::StringifyMessage(*this, internal::Option::kShort,
+                                    FieldReporterLevel::kShortDebugString);
+}
+
+std::string Message::Utf8DebugString() const {
+  return internal::StringifyMessage(*this, internal::Option::kUTF8,
+                                    FieldReporterLevel::kUtf8DebugString);
+}
+
+void Message::PrintDebugString() const { printf("%s", DebugString().c_str()); }
+
+PROTOBUF_EXPORT std::string ShortFormat(const Message& message) {
+  return internal::StringifyMessage(message, internal::Option::kShort,
+                                    FieldReporterLevel::kShortFormat);
+}
+
+PROTOBUF_EXPORT std::string Utf8Format(const Message& message) {
+  return internal::StringifyMessage(message, internal::Option::kUTF8,
+                                    FieldReporterLevel::kUtf8Format);
+}
+
+
+// ===========================================================================
+// Implementation of the parse information tree class.
+void TextFormat::ParseInfoTree::RecordLocation(
+    const FieldDescriptor* field, TextFormat::ParseLocationRange range) {
+  auto& vec = locations_[field];
+  if (!vec.empty() && vec.back().full.start.line == -1) {
+    vec.back().full = range;
+  } else {
+    FieldLocation loc;
+    loc.full = range;
+    vec.push_back(std::move(loc));
+  }
+}
+
+void TextFormat::ParseInfoTree::RecordNameLocation(
+    const FieldDescriptor* field, TextFormat::ParseLocationRange range) {
+  auto& vec = locations_[field];
+  if (!vec.empty() && vec.back().name.start.line == -1 &&
+      vec.back().full.start.line == -1) {
+    vec.back().name = range;
+  } else {
+    FieldLocation loc;
+    loc.name = range;
+    vec.push_back(std::move(loc));
+  }
+}
+
+void TextFormat::ParseInfoTree::RecordValueLocation(
+    const FieldDescriptor* field, TextFormat::ParseLocationRange range) {
+  auto& vec = locations_[field];
+  if (vec.empty() || vec.back().full.start.line != -1) {
+    FieldLocation loc;
+    loc.values.push_back(range);
+    vec.push_back(std::move(loc));
+  } else {
+    vec.back().values.push_back(range);
+  }
+}
+
+TextFormat::ParseInfoTree* TextFormat::ParseInfoTree::CreateNested(
+    const FieldDescriptor* field) {
+  // Owned by us in the map.
+  auto& vec = nested_[field];
+  vec.emplace_back(new TextFormat::ParseInfoTree());
+  return vec.back().get();
+}
+
+void CheckFieldIndex(const FieldDescriptor* field, int index) {
+  if (field == nullptr) {
+    return;
+  }
+
+  if (field->is_repeated() && index == -1) {
+    ABSL_DLOG(FATAL) << "Index must be in range of repeated field values. "
+                     << "Field: " << field->name();
+  } else if (!field->is_repeated() && index != -1) {
+    ABSL_DLOG(FATAL) << "Index must be -1 for singular fields. "
+                     << "Field: " << field->name();
+  }
+}
+
+TextFormat::ParseLocationRange TextFormat::ParseInfoTree::GetLocationRange(
+    const FieldDescriptor* field, int index) const {
+  CheckFieldIndex(field, index);
+  if (index == -1) {
+    index = 0;
+  }
+
+  auto it = locations_.find(field);
+  if (it == locations_.end() ||
+      index >= static_cast<int64_t>(it->second.size())) {
+    return TextFormat::ParseLocationRange();
+  }
+
+  return it->second[static_cast<size_t>(index)].full;
+}
+
+TextFormat::ParseLocation TextFormat::ParseInfoTree::GetLocation(
+    const FieldDescriptor* field, int index) const {
+  return GetLocationRange(field, index).start;
+}
+
+absl::StatusOr<TextFormat::FieldLocation>
+TextFormat::ParseInfoTree::GetFieldLocation(
+    const FieldDescriptor* field) const {
+  if (field == nullptr) {
+    return absl::InvalidArgumentError("Field is null");
+  }
+  if (field->is_repeated()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "Field ", field->name(),
+        " is repeated. Use GetFieldLocation(field, index) version."));
+  }
+  auto it = locations_.find(field);
+  if (it == locations_.end() || it->second.empty()) {
+    return absl::NotFoundError(
+        absl::StrCat("Field ", field->name(), " not set."));
+  }
+  return it->second[0];
+}
+
+absl::StatusOr<TextFormat::FieldLocation>
+TextFormat::ParseInfoTree::GetFieldLocation(const FieldDescriptor* field,
+                                            uint32_t index) const {
+  if (field == nullptr) {
+    return absl::InvalidArgumentError("Field is null");
+  }
+  if (!field->is_repeated()) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Field ", field->name(),
+                     " is singular. Use GetFieldLocation(field) version."));
+  }
+  auto it = locations_.find(field);
+  if (it == locations_.end() ||
+      index >= static_cast<int64_t>(it->second.size())) {
+    return absl::NotFoundError(
+        absl::StrCat("Field ", field->name(),
+                     " not found or out of bounds for index ", index, "."));
+  }
+  return it->second[index];
+}
+
+TextFormat::ParseInfoTree* TextFormat::ParseInfoTree::GetTreeForNested(
+    const FieldDescriptor* field, int index) const {
+  CheckFieldIndex(field, index);
+  if (index == -1) {
+    index = 0;
+  }
+
+  auto it = nested_.find(field);
+  if (it == nested_.end() || index >= static_cast<int64_t>(it->second.size())) {
+    return nullptr;
+  }
+
+  return it->second[static_cast<size_t>(index)].get();
+}
+
+namespace {
+// These functions implement the behavior of the "default" TextFormat::Finder,
+// they are defined as standalone to be called when finder_ is nullptr.
+const FieldDescriptor* DefaultFinderFindExtension(Message* message,
+                                                  const std::string& name) {
+  const Descriptor* descriptor = message->GetDescriptor();
+  return descriptor->file()->pool()->FindExtensionByPrintableName(descriptor,
+                                                                  name);
+}
+
+const FieldDescriptor* DefaultFinderFindExtensionByNumber(
+    const Descriptor* descriptor, int number) {
+  return descriptor->file()->pool()->FindExtensionByNumber(descriptor, number);
+}
+
+const Descriptor* DefaultFinderFindAnyType(const Message& message,
+                                           const std::string& url_prefix,
+                                           const std::string& name) {
+  return message.GetDescriptor()->file()->pool()->FindMessageTypeByName(name);
+}
+}  // namespace
+
+auto TextFormat::Parser::UnsetFieldsMetadata::GetUnsetFieldId(
+    const Message& message, const FieldDescriptor& fd) -> Id {
+  return {&message, &fd};
+}
+
+// ===========================================================================
+// Internal class for parsing an ASCII representation of a Protocol Message.
+// This class makes use of the Protocol Message compiler's tokenizer found
+// in //third_party/protobuf/io/tokenizer.h. Note that class's Parse
+// method is *not* thread-safe and should only be used in a single thread at
+// a time.
+
+// Makes code slightly more readable.  The meaning of "DO(foo)" is
+// "Execute foo and fail if it fails.", where failure is indicated by
+// returning false. Borrowed from parser.cc (Thanks Kenton!).
+#define DO(STATEMENT) \
+  if (STATEMENT) {    \
+  } else {            \
+    return false;     \
+  }
+
+class TextFormat::Parser::ParserImpl {
+ public:
+  // Determines if repeated values for non-repeated fields and
+  // oneofs are permitted, e.g., the string "foo: 1 foo: 2" for a
+  // required/optional field named "foo", or "baz: 1 bar: 2"
+  // where "baz" and "bar" are members of the same oneof.
+  enum SingularOverwritePolicy {
+    ALLOW_SINGULAR_OVERWRITES = 0,   // the last value is retained
+    FORBID_SINGULAR_OVERWRITES = 1,  // an error is issued
+  };
+
+  ParserImpl(const Descriptor* root_message_type,
+             io::ZeroCopyInputStream* input_stream,
+             io::ErrorCollector* error_collector,
+             const TextFormat::Finder* finder, ParseInfoTree* parse_info_tree,
+             SingularOverwritePolicy singular_overwrite_policy,
+             bool allow_case_insensitive_field, bool allow_unknown_field,
+             bool allow_unknown_extension, bool allow_unknown_enum,
+             bool allow_field_number, bool allow_relaxed_whitespace,
+             bool allow_partial, int recursion_limit,
+             UnsetFieldsMetadata* no_op_fields)
+      : error_collector_(error_collector),
+        finder_(finder),
+        parse_info_tree_(parse_info_tree),
+        tokenizer_error_collector_(this),
+        tokenizer_(input_stream, &tokenizer_error_collector_),
+        root_message_type_(root_message_type),
+        singular_overwrite_policy_(singular_overwrite_policy),
+        allow_case_insensitive_field_(allow_case_insensitive_field),
+        allow_unknown_field_(allow_unknown_field),
+        allow_unknown_extension_(allow_unknown_extension),
+        allow_unknown_enum_(allow_unknown_enum),
+        allow_field_number_(allow_field_number),
+        allow_partial_(allow_partial),
+        initial_recursion_limit_(recursion_limit),
+        recursion_limit_(recursion_limit),
+        had_silent_marker_(false),
+        had_errors_(false),
+        no_op_fields_(no_op_fields) {
+    // For backwards-compatibility with proto1, we need to allow the 'f' suffix
+    // for floats.
+    tokenizer_.set_allow_f_after_float(true);
+
+    // '#' starts a comment.
+    tokenizer_.set_comment_style(io::Tokenizer::SH_COMMENT_STYLE);
+
+    if (allow_relaxed_whitespace) {
+      tokenizer_.set_require_space_after_number(false);
+      tokenizer_.set_allow_multiline_strings(true);
+    }
+
+    // Consume the starting token.
+    tokenizer_.Next();
+  }
+  ParserImpl(const ParserImpl&) = delete;
+  ParserImpl& operator=(const ParserImpl&) = delete;
+  ~ParserImpl() = default;
+
+  // Parses the ASCII representation specified in input and saves the
+  // information into the output pointer (a Message). Returns
+  // false if an error occurs (an error will also be logged to
+  // ABSL_LOG(ERROR)).
+  bool Parse(Message* output) {
+    // Consume fields until we cannot do so anymore.
+    while (true) {
+      if (LookingAtType(io::Tokenizer::TYPE_END)) {
+        // Ensures recursion limit properly unwinded, but only for success
+        // cases. This implicitly avoids the check when `Parse` returns false
+        // via `DO(...)`.
+        ABSL_DCHECK(had_errors_ || recursion_limit_ == initial_recursion_limit_)
+            << "Recursion limit at end of parse should be "
+            << initial_recursion_limit_ << ", but was " << recursion_limit_
+            << ". Difference of " << initial_recursion_limit_ - recursion_limit_
+            << " stack frames not accounted for stack unwind.";
+
+        return !had_errors_;
+      }
+
+      DO(ConsumeField(output));
+    }
+  }
+
+  bool ParseField(const FieldDescriptor* field, Message* output) {
+    bool suc;
+    if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+      suc = ConsumeFieldMessage(output, output->GetReflection(), field);
+    } else {
+      suc = ConsumeFieldValue(output, output->GetReflection(), field);
+    }
+    return suc && LookingAtType(io::Tokenizer::TYPE_END);
+  }
+
+  void ReportError(int line, int col, absl::string_view message) {
+    had_errors_ = true;
+    if (error_collector_ == nullptr) {
+      if (line >= 0) {
+        ABSL_LOG(ERROR) << "Error parsing text-format "
+                        << root_message_type_->full_name() << ": " << (line + 1)
+                        << ":" << (col + 1) << ": " << message;
+      } else {
+        ABSL_LOG(ERROR) << "Error parsing text-format "
+                        << root_message_type_->full_name() << ": " << message;
+      }
+    } else {
+      error_collector_->RecordError(line, col, message);
+    }
+  }
+
+  void ReportWarning(int line, int col, const absl::string_view message) {
+    if (error_collector_ == nullptr) {
+      if (line >= 0) {
+        ABSL_LOG_EVERY_POW_2(WARNING)
+            << "Warning parsing text-format " << root_message_type_->full_name()
+            << ": " << (line + 1) << ":" << (col + 1) << " (N = " << COUNTER
+            << "): " << message;
+      } else {
+        ABSL_LOG_EVERY_POW_2(WARNING)
+            << "Warning parsing text-format " << root_message_type_->full_name()
+            << " (N = " << COUNTER << "): " << message;
+      }
+    } else {
+      error_collector_->RecordWarning(line, col, message);
+    }
+  }
+
+ private:
+  static constexpr int32_t kint32max = std::numeric_limits<int32_t>::max();
+  static constexpr uint32_t kuint32max = std::numeric_limits<uint32_t>::max();
+  static constexpr int64_t kint64min = std::numeric_limits<int64_t>::min();
+  static constexpr int64_t kint64max = std::numeric_limits<int64_t>::max();
+  static constexpr uint64_t kuint64max = std::numeric_limits<uint64_t>::max();
+
+  // Reports an error with the given message with information indicating
+  // the position (as derived from the current token).
+  void ReportError(absl::string_view message) {
+    ReportError(tokenizer_.current().line, tokenizer_.current().column,
+                message);
+  }
+
+  // Reports a warning with the given message with information indicating
+  // the position (as derived from the current token).
+  void ReportWarning(absl::string_view message) {
+    ReportWarning(tokenizer_.current().line, tokenizer_.current().column,
+                  message);
+  }
+
+  // Consumes the specified message with the given starting delimiter.
+  // This method checks to see that the end delimiter at the conclusion of
+  // the consumption matches the starting delimiter passed in here.
+  bool ConsumeMessage(Message* message, const std::string& delimiter) {
+    while (!LookingAt(">") && !LookingAt("}")) {
+      DO(ConsumeField(message));
+    }
+
+    // Confirm that we have a valid ending delimiter.
+    DO(Consume(delimiter));
+    return true;
+  }
+
+  // Consume either "<" or "{".
+  bool ConsumeMessageDelimiter(std::string* delimiter) {
+    if (TryConsume("<")) {
+      *delimiter = ">";
+    } else {
+      DO(Consume("{"));
+      *delimiter = "}";
+    }
+    return true;
+  }
+
+  // Consumes the current field (as returned by the tokenizer) on the
+  // passed in message.
+  bool ConsumeField(Message* message) {
+    const Reflection* reflection = message->GetReflection();
+    const Descriptor* descriptor = message->GetDescriptor();
+
+    std::string field_name;
+    bool reserved_field = false;
+    const FieldDescriptor* field = nullptr;
+    int start_line = tokenizer_.current().line;
+    int start_column = tokenizer_.current().column;
+
+    auto record_value_location = [&](int v_start_line, int v_start_column) {
+      if (parse_info_tree_ != nullptr && field != nullptr) {
+        int v_end_line = tokenizer_.previous().line;
+        int v_end_column = tokenizer_.previous().end_column;
+        RecordValueLocation(
+            parse_info_tree_, field,
+            ParseLocationRange(ParseLocation(v_start_line, v_start_column),
+                               ParseLocation(v_end_line, v_end_column)));
+      }
+    };
+
+    auto record_name_location = [&](const FieldDescriptor* f,
+                                    const ParseLocationRange& n_range) {
+      if (parse_info_tree_ != nullptr && f != nullptr) {
+        RecordNameLocation(parse_info_tree_, f, n_range);
+      }
+    };
+
+    auto skip_parsing = [&](bool result) {
+      // For historical reasons, fields may optionally be separated by commas or
+      // semicolons.
+      TryConsume(";") || TryConsume(",");
+
+      // If a parse info tree exists, add the location for the parsed
+      // field.
+      if (parse_info_tree_ != nullptr) {
+        int end_line = tokenizer_.previous().line;
+        int end_column = tokenizer_.previous().end_column;
+
+        RecordLocation(
+            parse_info_tree_, field,
+            ParseLocationRange(ParseLocation(start_line, start_column),
+                               ParseLocation(end_line, end_column)));
+      }
+
+      return result;
+    };
+
+    const FieldDescriptor* any_type_url_field;
+    const FieldDescriptor* any_value_field;
+    if (internal::GetAnyFieldDescriptors(*message, &any_type_url_field,
+                                         &any_value_field) &&
+        LookingAt("[")) {
+      int n_start_line = tokenizer_.current().line;
+      int n_start_column = tokenizer_.current().column;
+      std::string full_type_name, url_prefix;
+      DO(ConsumeAnyTypeUrlOrFullTypeName(full_type_name, url_prefix));
+      int n_end_line = tokenizer_.previous().line;
+      int n_end_column = tokenizer_.previous().end_column;
+      if (url_prefix.empty()) {
+        ReportError("Type URL prefix is missing");
+        return false;
+      }
+      std::string url_prefix_and_full_type_name =
+          absl::StrCat(url_prefix, full_type_name);
+      TryConsumeWhitespace();
+      // ':' is optional between message labels and values.
+      if (TryConsumeBeforeWhitespace(":")) {
+        TryConsumeWhitespace();
+      }
+      std::string serialized_value;
+      const Descriptor* value_descriptor =
+          finder_
+              ? finder_->FindAnyType(*message, url_prefix, full_type_name)
+              : DefaultFinderFindAnyType(*message, url_prefix, full_type_name);
+      if (value_descriptor == nullptr) {
+        ReportError(absl::StrCat("Could not find type \"",
+                                 url_prefix_and_full_type_name,
+                                 "\" stored in google.protobuf.Any."));
+        return false;
+      }
+      int v_start_line = tokenizer_.current().line;
+      int v_start_column = tokenizer_.current().column;
+      DO(ConsumeAnyValue(value_descriptor, &serialized_value));
+      record_value_location(v_start_line, v_start_column);
+
+      record_name_location(
+          any_type_url_field,
+          ParseLocationRange(ParseLocation(n_start_line, n_start_column),
+                             ParseLocation(n_end_line, n_end_column)));
+
+      if (singular_overwrite_policy_ == FORBID_SINGULAR_OVERWRITES) {
+        // Fail if any_type_url_field has already been specified.
+        if ((!any_type_url_field->is_repeated() &&
+             reflection->HasField(*message, any_type_url_field)) ||
+            (!any_value_field->is_repeated() &&
+             reflection->HasField(*message, any_value_field))) {
+          ReportError("Non-repeated Any specified multiple times.");
+          return false;
+        }
+      }
+      reflection->SetString(message, any_type_url_field,
+                            std::move(url_prefix_and_full_type_name));
+      reflection->SetString(message, any_value_field,
+                            std::move(serialized_value));
+      return skip_parsing(true);
+    }
+    if (LookingAt("[")) {
+      // Extension.
+      int n_start_line = tokenizer_.current().line;
+      int n_start_column = tokenizer_.current().column;
+      std::string url_prefix;
+      DO(ConsumeAnyTypeUrlOrFullTypeName(field_name, url_prefix));
+      int n_end_line = tokenizer_.previous().line;
+      int n_end_column = tokenizer_.previous().end_column;
+      if (!url_prefix.empty()) {
+        ReportError("Extension name contains \"/\"");
+        return false;
+      }
+      TryConsumeWhitespace();
+
+      field = finder_ ? finder_->FindExtension(message, field_name)
+                      : DefaultFinderFindExtension(message, field_name);
+
+      record_name_location(
+          field, ParseLocationRange(ParseLocation(n_start_line, n_start_column),
+                                    ParseLocation(n_end_line, n_end_column)));
+
+      if (field == nullptr) {
+        if (!allow_unknown_field_ && !allow_unknown_extension_) {
+          ReportError(absl::StrCat("Extension \"", field_name,
+                                   "\" is not defined or "
+                                   "is not an extension of \"",
+                                   descriptor->full_name(), "\"."));
+          return false;
+        } else {
+          ReportWarning(absl::StrCat(
+              "Ignoring extension \"", field_name,
+              "\" which is not defined or is not an extension of \"",
+              descriptor->full_name(), "\"."));
+        }
+      }
+    } else {
+      int n_start_line = tokenizer_.current().line;
+      int n_start_column = tokenizer_.current().column;
+      DO(ConsumeIdentifierBeforeWhitespace(&field_name));
+      int n_end_line = tokenizer_.previous().line;
+      int n_end_column = tokenizer_.previous().end_column;
+      TryConsumeWhitespace();
+
+      int32_t field_number;
+      if (allow_field_number_ && absl::SimpleAtoi(field_name, &field_number)) {
+        if (descriptor->IsExtensionNumber(field_number)) {
+          field = finder_
+                      ? finder_->FindExtensionByNumber(descriptor, field_number)
+                      : DefaultFinderFindExtensionByNumber(descriptor,
+                                                           field_number);
+        } else if (descriptor->IsReservedNumber(field_number)) {
+          reserved_field = true;
+        } else {
+          field = descriptor->FindFieldByNumber(field_number);
+        }
+      } else {
+        field = descriptor->FindFieldByName(field_name);
+        // Group-like delimited fields will accept both the capitalized type
+        // names as well.
+        if (field == nullptr) {
+          std::string lower_field_name = field_name;
+          absl::AsciiStrToLower(&lower_field_name);
+          field = descriptor->FindFieldByName(lower_field_name);
+          // If the case-insensitive match worked but the field is NOT a group,
+          if (field != nullptr && !internal::cpp::IsGroupLike(*field)) {
+            field = nullptr;
+          }
+          if (field != nullptr && field->message_type()->name() != field_name) {
+            field = nullptr;
+          }
+        }
+
+        if (field == nullptr && allow_case_insensitive_field_) {
+          std::string lower_field_name = field_name;
+          absl::AsciiStrToLower(&lower_field_name);
+          field = descriptor->FindFieldByLowercaseName(lower_field_name);
+        }
+
+        if (field == nullptr) {
+          reserved_field = descriptor->IsReservedName(field_name);
+        }
+      }
+      record_name_location(
+          field, ParseLocationRange(ParseLocation(n_start_line, n_start_column),
+                                    ParseLocation(n_end_line, n_end_column)));
+      if (field == nullptr && !reserved_field) {
+        if (!allow_unknown_field_) {
+          ReportError(absl::StrCat("Message type \"", descriptor->full_name(),
+                                   "\" has no field named \"", field_name,
+                                   "\"."));
+          return false;
+        } else {
+          ReportWarning(absl::StrCat("Message type \"", descriptor->full_name(),
+                                     "\" has no field named \"", field_name,
+                                     "\"."));
+        }
+      }
+    }
+
+    // Skips unknown or reserved fields.
+    if (field == nullptr) {
+      ABSL_CHECK(allow_unknown_field_ || allow_unknown_extension_ ||
+                 reserved_field);
+
+      // Try to guess the type of this field.
+      // If this field is not a message, there should be a ":" between the
+      // field name and the field value and also the field value should not
+      // start with "{" or "<" which indicates the beginning of a message body.
+      // If there is no ":" or there is a "{" or "<" after ":", this field has
+      // to be a message or the input is ill-formed.
+      if (TryConsumeBeforeWhitespace(":")) {
+        TryConsumeWhitespace();
+        if (!LookingAt("{") && !LookingAt("<")) {
+          return skip_parsing(SkipFieldValue());
+        }
+      }
+      return skip_parsing(SkipFieldMessage());
+    }
+
+    if (field->options().deprecated()) {
+      ReportWarning(absl::StrCat("text format contains deprecated field \"",
+                                 field_name, "\""));
+    }
+
+    if (singular_overwrite_policy_ == FORBID_SINGULAR_OVERWRITES) {
+      // Fail if the field is not repeated and it has already been specified.
+      if (!field->is_repeated() && reflection->HasField(*message, field)) {
+        ReportError(absl::StrCat("Non-repeated field \"", field_name,
+                                 "\" is specified multiple times."));
+        return false;
+      }
+      // Fail if the field is a member of a oneof and another member has already
+      // been specified.
+      const OneofDescriptor* oneof = field->containing_oneof();
+      if (oneof != nullptr && reflection->HasOneof(*message, oneof)) {
+        const FieldDescriptor* other_field =
+            reflection->GetOneofFieldDescriptor(*message, oneof);
+        ReportError(absl::StrCat("Field \"", field_name,
+                                 "\" is specified along with "
+                                 "field \"",
+                                 other_field->name(),
+                                 "\", another member "
+                                 "of oneof \"",
+                                 oneof->name(), "\"."));
+        return false;
+      }
+    }
+
+    // Perform special handling for embedded message types.
+    if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+      // ':' is optional here.
+      bool consumed_semicolon = TryConsumeBeforeWhitespace(":");
+      if (consumed_semicolon) {
+        TryConsumeWhitespace();
+      }
+      if (consumed_semicolon && field->options().weak() &&
+          LookingAtType(io::Tokenizer::TYPE_STRING)) {
+        // we are getting a bytes string for a weak field.
+        int v_start_line = tokenizer_.current().line;
+        int v_start_column = tokenizer_.current().column;
+        std::string tmp;
+        DO(ConsumeString(&tmp));
+        MessageFactory* factory =
+            finder_ ? finder_->FindExtensionFactory(field) : nullptr;
+        // TODO: Remove this suppression.
+        (void)reflection->MutableMessage(message, field, factory)
+            ->ParseFromString(tmp);
+        record_value_location(v_start_line, v_start_column);
+        return skip_parsing(true);
+      }
+    } else {
+      // ':' is required here.
+      DO(ConsumeBeforeWhitespace(":"));
+      TryConsumeWhitespace();
+    }
+
+    if (field->is_repeated() && TryConsume("[")) {
+      // Short repeated format, e.g.  "foo: [1, 2, 3]".
+      if (!TryConsume("]")) {
+        // "foo: []" is treated as empty.
+        while (true) {
+          int v_start_line = tokenizer_.current().line;
+          int v_start_column = tokenizer_.current().column;
+          if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+            // Perform special handling for embedded message types.
+            DO(ConsumeFieldMessage(message, reflection, field));
+          } else {
+            DO(ConsumeFieldValue(message, reflection, field));
+          }
+          record_value_location(v_start_line, v_start_column);
+          if (TryConsume("]")) {
+            break;
+          }
+          DO(Consume(","));
+        }
+      }
+    } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+      int v_start_line = tokenizer_.current().line;
+      int v_start_column = tokenizer_.current().column;
+      DO(ConsumeFieldMessage(message, reflection, field));
+      record_value_location(v_start_line, v_start_column);
+    } else {
+      int v_start_line = tokenizer_.current().line;
+      int v_start_column = tokenizer_.current().column;
+      DO(ConsumeFieldValue(message, reflection, field));
+      record_value_location(v_start_line, v_start_column);
+    }
+
+    return skip_parsing(true);
+  }
+
+  // Skips the next field including the field's name and value.
+  bool SkipField() {
+    std::string field_name;
+    if (LookingAt("[")) {
+      // Extension name or type URL.
+      std::string full_type_name, url_prefix;
+      DO(ConsumeAnyTypeUrlOrFullTypeName(full_type_name, url_prefix));
+      field_name = absl::StrCat(url_prefix, full_type_name);
+    } else {
+      DO(ConsumeIdentifierBeforeWhitespace(&field_name));
+    }
+    TryConsumeWhitespace();
+
+    // Try to guess the type of this field.
+    // If this field is not a message, there should be a ":" between the
+    // field name and the field value and also the field value should not
+    // start with "{" or "<" which indicates the beginning of a message body.
+    // If there is no ":" or there is a "{" or "<" after ":", this field has
+    // to be a message or the input is ill-formed.
+    if (TryConsumeBeforeWhitespace(":")) {
+      TryConsumeWhitespace();
+      if (!LookingAt("{") && !LookingAt("<")) {
+        DO(SkipFieldValue());
+      } else {
+        DO(SkipFieldMessage());
+      }
+    } else {
+      DO(SkipFieldMessage());
+    }
+    // For historical reasons, fields may optionally be separated by commas or
+    // semicolons.
+    TryConsume(";") || TryConsume(",");
+    return true;
+  }
+
+  bool ConsumeFieldMessage(Message* message, const Reflection* reflection,
+                           const FieldDescriptor* field) {
+    if (--recursion_limit_ < 0) {
+      ReportError(
+          absl::StrCat("Message is too deep, the parser exceeded the "
+                       "configured recursion limit of ",
+                       initial_recursion_limit_, "."));
+      return false;
+    }
+    // If the parse information tree is not nullptr, create a nested one
+    // for the nested message.
+    ParseInfoTree* parent = parse_info_tree_;
+    if (parent != nullptr) {
+      parse_info_tree_ = CreateNested(parent, field);
+    }
+
+    std::string delimiter;
+    DO(ConsumeMessageDelimiter(&delimiter));
+    MessageFactory* factory =
+        finder_ ? finder_->FindExtensionFactory(field) : nullptr;
+    if (field->is_repeated()) {
+      DO(ConsumeMessage(reflection->AddMessage(message, field, factory),
+                        delimiter));
+    } else {
+      DO(ConsumeMessage(reflection->MutableMessage(message, field, factory),
+                        delimiter));
+    }
+
+    ++recursion_limit_;
+
+    // Reset the parse information tree.
+    parse_info_tree_ = parent;
+    return true;
+  }
+
+  // Skips the whole body of a message including the beginning delimiter and
+  // the ending delimiter.
+  bool SkipFieldMessage() {
+    if (--recursion_limit_ < 0) {
+      ReportError(
+          absl::StrCat("Message is too deep, the parser exceeded the "
+                       "configured recursion limit of ",
+                       initial_recursion_limit_, "."));
+      return false;
+    }
+
+    std::string delimiter;
+    DO(ConsumeMessageDelimiter(&delimiter));
+    while (!LookingAt(">") && !LookingAt("}")) {
+      DO(SkipField());
+    }
+    DO(Consume(delimiter));
+
+    ++recursion_limit_;
+    return true;
+  }
+
+  bool ConsumeFieldValue(Message* message, const Reflection* reflection,
+                         const FieldDescriptor* field) {
+// Define an easy to use macro for setting fields. This macro checks
+// to see if the field is repeated (in which case we need to use the Add
+// methods or not (in which case we need to use the Set methods).
+// When checking for no-op operations, We verify that both the existing value in
+// the message and the new value are the default. If the existing field value is
+// not the default, setting it to the default should not be treated as a no-op.
+// The pointer of this is kept in no_op_fields_ for bookkeeping.
+#define SET_FIELD(CPPTYPE, CPPTYPELCASE, VALUE)                    \
+  if (field->is_repeated()) {                                      \
+    reflection->Add##CPPTYPE(message, field, VALUE);               \
+  } else {                                                         \
+    if (no_op_fields_ && !field->has_presence() &&                 \
+        field->default_value_##CPPTYPELCASE() ==                   \
+            reflection->Get##CPPTYPE(*message, field) &&           \
+        field->default_value_##CPPTYPELCASE() == VALUE) {          \
+      no_op_fields_->ids_.insert(                                  \
+          UnsetFieldsMetadata::GetUnsetFieldId(*message, *field)); \
+    } else {                                                       \
+      reflection->Set##CPPTYPE(message, field, std::move(VALUE));  \
+    }                                                              \
+  }
+
+    switch (field->cpp_type()) {
+      case FieldDescriptor::CPPTYPE_INT32: {
+        int64_t value;
+        DO(ConsumeSignedInteger(&value, kint32max));
+        SET_FIELD(Int32, int32, static_cast<int32_t>(value));
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_UINT32: {
+        uint64_t value;
+        DO(ConsumeUnsignedInteger(&value, kuint32max));
+        SET_FIELD(UInt32, uint32, static_cast<uint32_t>(value));
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_INT64: {
+        int64_t value;
+        DO(ConsumeSignedInteger(&value, kint64max));
+        SET_FIELD(Int64, int64, value);
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_UINT64: {
+        uint64_t value;
+        DO(ConsumeUnsignedInteger(&value, kuint64max));
+        SET_FIELD(UInt64, uint64, value);
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_FLOAT: {
+        double value;
+        DO(ConsumeDouble(&value));
+        SET_FIELD(Float, float, io::SafeDoubleToFloat(value));
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_DOUBLE: {
+        double value;
+        DO(ConsumeDouble(&value));
+        SET_FIELD(Double, double, value);
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_STRING: {
+        std::string value;
+        DO(ConsumeString(&value));
+        SET_FIELD(String, string, std::move(value));
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_BOOL: {
+        if (LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
+          uint64_t value;
+          DO(ConsumeUnsignedInteger(&value, 1));
+          SET_FIELD(Bool, bool, static_cast<bool>(value));
+        } else {
+          std::string value;
+          DO(ConsumeIdentifier(&value));
+          if (value == "true" || value == "True" || value == "t") {
+            SET_FIELD(Bool, bool, true);
+          } else if (value == "false" || value == "False" || value == "f") {
+            SET_FIELD(Bool, bool, false);
+          } else {
+            ReportError(absl::StrCat("Invalid value for boolean field \"",
+                                     field->name(), "\". Value: \"", value,
+                                     "\"."));
+            return false;
+          }
+        }
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_ENUM: {
+        std::string value;
+        int64_t int_value = kint64max;
+        const EnumDescriptor* enum_type = field->enum_type();
+        const EnumValueDescriptor* enum_value = nullptr;
+
+        if (LookingAtType(io::Tokenizer::TYPE_IDENTIFIER)) {
+          DO(ConsumeIdentifier(&value));
+          // Find the enumeration value.
+          enum_value = enum_type->FindValueByName(value);
+
+        } else if (LookingAt("-") ||
+                   LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
+          DO(ConsumeSignedInteger(&int_value, kint32max));
+          value = absl::StrCat(int_value);  // for error reporting
+          enum_value = enum_type->FindValueByNumber(int_value);
+        } else {
+          ReportError(absl::StrCat("Expected integer or identifier, got: ",
+                                   tokenizer_.current().text));
+          return false;
+        }
+
+        if (enum_value == nullptr) {
+          if (int_value != kint64max &&
+              !field->legacy_enum_field_treated_as_closed()) {
+            SET_FIELD(EnumValue, int64, int_value);
+            return true;
+          } else if (!allow_unknown_enum_) {
+            ReportError(absl::StrCat("Unknown enumeration value of \"", value,
+                                     "\" for field \"", field->name(), "\"."));
+            return false;
+          } else {
+            ReportWarning(absl::StrCat("Unknown enumeration value of \"", value,
+                                       "\" for field \"", field->name(),
+                                       "\"."));
+            return true;
+          }
+        }
+
+        SET_FIELD(Enum, enum, enum_value);
+        break;
+      }
+
+      case FieldDescriptor::CPPTYPE_MESSAGE: {
+        // We should never get here. Put here instead of a default
+        // so that if new types are added, we get a nice compiler warning.
+        ABSL_LOG(FATAL) << "Reached an unintended state: CPPTYPE_MESSAGE";
+        break;
+      }
+    }
+#undef SET_FIELD
+    return true;
+  }
+
+  bool SkipFieldValue() {
+    if (--recursion_limit_ < 0) {
+      ReportError(
+          absl::StrCat("Message is too deep, the parser exceeded the "
+                       "configured recursion limit of ",
+                       initial_recursion_limit_, "."));
+      return false;
+    }
+
+    if (LookingAtType(io::Tokenizer::TYPE_STRING)) {
+      while (LookingAtType(io::Tokenizer::TYPE_STRING)) {
+        tokenizer_.Next();
+      }
+      ++recursion_limit_;
+      return true;
+    }
+    if (TryConsume("[")) {
+      if (!TryConsume("]")) {
+        while (true) {
+          if (!LookingAt("{") && !LookingAt("<")) {
+            DO(SkipFieldValue());
+          } else {
+            DO(SkipFieldMessage());
+          }
+          if (TryConsume("]")) {
+            break;
+          }
+          DO(Consume(","));
+        }
+      }
+      ++recursion_limit_;
+      return true;
+    }
+    // Possible field values other than string:
+    //   12345        => TYPE_INTEGER
+    //   -12345       => TYPE_SYMBOL + TYPE_INTEGER
+    //   1.2345       => TYPE_FLOAT
+    //   -1.2345      => TYPE_SYMBOL + TYPE_FLOAT
+    //   inf          => TYPE_IDENTIFIER
+    //   -inf         => TYPE_SYMBOL + TYPE_IDENTIFIER
+    //   TYPE_INTEGER => TYPE_IDENTIFIER
+    // Divides them into two group, one with TYPE_SYMBOL
+    // and the other without:
+    //   Group one:
+    //     12345        => TYPE_INTEGER
+    //     1.2345       => TYPE_FLOAT
+    //     inf          => TYPE_IDENTIFIER
+    //     TYPE_INTEGER => TYPE_IDENTIFIER
+    //   Group two:
+    //     -12345       => TYPE_SYMBOL + TYPE_INTEGER
+    //     -1.2345      => TYPE_SYMBOL + TYPE_FLOAT
+    //     -inf         => TYPE_SYMBOL + TYPE_IDENTIFIER
+    // As we can see, the field value consists of an optional '-' and one of
+    // TYPE_INTEGER, TYPE_FLOAT and TYPE_IDENTIFIER.
+    bool has_minus = TryConsume("-");
+    if (!LookingAtType(io::Tokenizer::TYPE_INTEGER) &&
+        !LookingAtType(io::Tokenizer::TYPE_FLOAT) &&
+        !LookingAtType(io::Tokenizer::TYPE_IDENTIFIER)) {
+      std::string text = tokenizer_.current().text;
+      ReportError(
+          absl::StrCat("Cannot skip field value, unexpected token: ", text));
+      ++recursion_limit_;
+      return false;
+    }
+    // Combination of '-' and TYPE_IDENTIFIER may result in an invalid field
+    // value while other combinations all generate valid values.
+    // We check if the value of this combination is valid here.
+    // TYPE_IDENTIFIER after a '-' should be one of the float values listed
+    // below:
+    //   inf, inff, infinity, nan
+    if (has_minus && LookingAtType(io::Tokenizer::TYPE_IDENTIFIER)) {
+      std::string text = tokenizer_.current().text;
+      absl::AsciiStrToLower(&text);
+      if (text != "inf" &&
+          text != "infinity" && text != "nan") {
+        ReportError(absl::StrCat("Invalid float number: ", text));
+        ++recursion_limit_;
+        return false;
+      }
+    }
+    tokenizer_.Next();
+    ++recursion_limit_;
+    return true;
+  }
+
+  // Returns true if the current token's text is equal to that specified.
+  bool LookingAt(const std::string& text) {
+    return tokenizer_.current().text == text;
+  }
+
+  // Returns true if the current token's type is equal to that specified.
+  bool LookingAtType(io::Tokenizer::TokenType token_type) {
+    return tokenizer_.current().type == token_type;
+  }
+
+  // Consumes an identifier and saves its value in the identifier parameter.
+  // Returns false if the token is not of type IDENTIFIER.
+  bool ConsumeIdentifier(std::string* identifier) {
+    if (LookingAtType(io::Tokenizer::TYPE_IDENTIFIER)) {
+      *identifier = tokenizer_.current().text;
+      tokenizer_.Next();
+      return true;
+    }
+
+    // If allow_field_number_ or allow_unknown_field_ is true, we should able
+    // to parse integer identifiers.
+    if ((allow_field_number_ || allow_unknown_field_ ||
+         allow_unknown_extension_) &&
+        LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
+      *identifier = tokenizer_.current().text;
+      tokenizer_.Next();
+      return true;
+    }
+
+    ReportError(
+        absl::StrCat("Expected identifier, got: ", tokenizer_.current().text));
+    return false;
+  }
+
+  // Similar to `ConsumeIdentifier`, but any following whitespace token may
+  // be reported.
+  bool ConsumeIdentifierBeforeWhitespace(std::string* identifier) {
+    tokenizer_.set_report_whitespace(true);
+    bool result = ConsumeIdentifier(identifier);
+    tokenizer_.set_report_whitespace(false);
+    return result;
+  }
+
+  // Consumes a string and saves its value in the text parameter.
+  // Returns false if the token is not of type STRING.
+  bool ConsumeString(std::string* text) {
+    if (!LookingAtType(io::Tokenizer::TYPE_STRING)) {
+      ReportError(
+          absl::StrCat("Expected string, got: ", tokenizer_.current().text));
+      return false;
+    }
+
+    text->clear();
+    while (LookingAtType(io::Tokenizer::TYPE_STRING)) {
+      io::Tokenizer::ParseStringAppend(tokenizer_.current().text, text);
+
+      tokenizer_.Next();
+    }
+
+    return true;
+  }
+
+  // Consumes a uint64_t and saves its value in the value parameter.
+  // Returns false if the token is not of type INTEGER.
+  bool ConsumeUnsignedInteger(uint64_t* value, uint64_t max_value) {
+    if (!LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
+      ReportError(
+          absl::StrCat("Expected integer, got: ", tokenizer_.current().text));
+      return false;
+    }
+
+    if (!io::Tokenizer::ParseInteger(tokenizer_.current().text, max_value,
+                                     value)) {
+      ReportError(absl::StrCat("Integer out of range (",
+                               tokenizer_.current().text, ")"));
+      return false;
+    }
+
+    tokenizer_.Next();
+    return true;
+  }
+
+  // Consumes an int64_t and saves its value in the value parameter.
+  // Note that since the tokenizer does not support negative numbers,
+  // we actually may consume an additional token (for the minus sign) in this
+  // method. Returns false if the token is not an integer
+  // (signed or otherwise).
+  bool ConsumeSignedInteger(int64_t* value, uint64_t max_value) {
+    bool negative = false;
+
+    if (TryConsume("-")) {
+      negative = true;
+      // Two's complement always allows one more negative integer than
+      // positive.
+      ++max_value;
+    }
+
+    uint64_t unsigned_value;
+
+    DO(ConsumeUnsignedInteger(&unsigned_value, max_value));
+
+    if (negative) {
+      if ((static_cast<uint64_t>(kint64max) + 1) == unsigned_value) {
+        *value = kint64min;
+      } else {
+        *value = -static_cast<int64_t>(unsigned_value);
+      }
+    } else {
+      *value = static_cast<int64_t>(unsigned_value);
+    }
+
+    return true;
+  }
+
+  // Consumes a double and saves its value in the value parameter.
+  // Accepts decimal numbers only, rejects hex or oct numbers.
+  bool ConsumeUnsignedDecimalAsDouble(double* value, uint64_t max_value) {
+    if (!LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
+      ReportError(
+          absl::StrCat("Expected integer, got: ", tokenizer_.current().text));
+      return false;
+    }
+
+    const std::string& text = tokenizer_.current().text;
+    if (IsHexNumber(text) || IsOctNumber(text)) {
+      ReportError(absl::StrCat("Expect a decimal number, got: ", text));
+      return false;
+    }
+
+    uint64_t uint64_value;
+    if (io::Tokenizer::ParseInteger(text, max_value, &uint64_value)) {
+      *value = static_cast<double>(uint64_value);
+    } else {
+      // Uint64 overflow, attempt to parse as a double instead.
+      *value = io::Tokenizer::ParseFloat(text);
+    }
+
+    tokenizer_.Next();
+    return true;
+  }
+
+  // Consumes a double and saves its value in the value parameter.
+  // Note that since the tokenizer does not support negative numbers,
+  // we actually may consume an additional token (for the minus sign) in this
+  // method. Returns false if the token is not a double
+  // (signed or otherwise).
+  bool ConsumeDouble(double* value) {
+    bool negative = false;
+
+    if (TryConsume("-")) {
+      negative = true;
+    }
+
+    // A double can actually be an integer, according to the tokenizer.
+    // Therefore, we must check both cases here.
+    if (LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
+      // We have found an integer value for the double.
+      DO(ConsumeUnsignedDecimalAsDouble(value, kuint64max));
+    } else if (LookingAtType(io::Tokenizer::TYPE_FLOAT)) {
+      // We have found a float value for the double.
+      *value = io::Tokenizer::ParseFloat(tokenizer_.current().text);
+
+      // Mark the current token as consumed.
+      tokenizer_.Next();
+    } else if (LookingAtType(io::Tokenizer::TYPE_IDENTIFIER)) {
+      std::string text = tokenizer_.current().text;
+      absl::AsciiStrToLower(&text);
+      if (text == "inf" ||
+          text == "infinity") {
+        *value = std::numeric_limits<double>::infinity();
+        tokenizer_.Next();
+      } else if (text == "nan") {
+        *value = std::numeric_limits<double>::quiet_NaN();
+        tokenizer_.Next();
+      } else {
+        ReportError(absl::StrCat("Expected double, got: ", text));
+        return false;
+      }
+    } else {
+      ReportError(
+          absl::StrCat("Expected double, got: ", tokenizer_.current().text));
+      return false;
+    }
+
+    if (negative) {
+      *value = -*value;
+    }
+
+    return true;
+  }
+
+  // Consumes an Any type URL of the form "some.domain/path/full.type.Name" or a
+  // full type name of the form "full.type.Name" enclosed in brackets (the
+  // enclosing `[]` are also consumed).
+  // The full type name is returned in `full_type_name`, and the type URL prefix
+  // is returned in `url_prefix` (which is empty if a full type name without a
+  // prefix is consumed).
+  bool ConsumeAnyTypeUrlOrFullTypeName(std::string& full_type_name,
+                                       std::string& url_prefix) {
+    // Collect all characters between [ and ] using the URL chars mode of
+    // the tokenizer. The mode switch must happen first so that it is active
+    // when we advance the tokenizer to the token following the "[" in the
+    // consume call.
+    tokenizer_.set_report_url_chars(true);
+    Consume("[");
+
+    std::string text;
+    std::string url_chars;
+    while (TryConsumeUrlChars(url_chars)) {
+      text.append(url_chars);
+    }
+
+    // The mode switch must happen first so that it is active when we advance
+    // the tokenizer to the token following the "]" in the consume call.
+    tokenizer_.set_report_url_chars(false);
+    DO(ConsumeBeforeWhitespace("]"));
+
+    size_t last_slash_pos = text.find_last_of('/');
+
+    if (last_slash_pos == std::string::npos) {
+      // No slash found, this must be a type name.
+      url_prefix = "";
+      full_type_name = text;  // validated below
+    } else {
+      // Found a slash, this must be a type URL.
+      url_prefix = text.substr(0, last_slash_pos + 1);
+      full_type_name = text.substr(last_slash_pos + 1);  // validated below
+
+      // Validate prefix
+      if (url_prefix == "/") {
+        ReportError("Type URL prefix is empty");
+        return false;
+      }
+
+      if (url_prefix[0] == '/') {
+        ReportError("Type URL starts with \"/\"");
+        return false;
+      }
+
+      // Validate URL percent encodings in prefix: Every '%' needs to be
+      // followed by two hex characters.
+      for (size_t i = 0; i < url_prefix.size(); ++i) {
+        static constexpr absl::CharSet kHexDigits =
+            absl::CharSet::AsciiHexDigits();
+        if (url_prefix[i] == '%' && (i + 2 >= url_prefix.size() ||
+                                     !kHexDigits.contains(url_prefix[i + 1]) ||
+                                     !kHexDigits.contains(url_prefix[i + 2]))) {
+          ReportError(absl::StrFormat("Invalid percent encode, got: \"%s\"",
+                                      url_prefix.substr(i, 3)));
+          return false;
+        }
+      }
+    }
+
+    // Validate type name: Must be non-empty and consist of valid identifiers
+    // separated by '.'.
+    for (absl::string_view identifier : absl::StrSplit(full_type_name, '.')) {
+      if (!tokenizer_.IsIdentifier(identifier)) {
+        ReportError(absl::StrFormat(
+            "Invalid identifier in type name, got: \"%s\"", identifier));
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  bool TryConsumeUrlChars(std::string& url_chars) {
+    if (!LookingAtType(io::Tokenizer::TYPE_URL_CHARS)) {
+      return false;
+    }
+
+    url_chars = tokenizer_.current().text;
+    tokenizer_.Next();
+    return true;
+  }
+
+  // A helper function for reconstructing Any::value. Consumes a text of
+  // full_type_name, then serializes it into serialized_value.
+  bool ConsumeAnyValue(const Descriptor* value_descriptor,
+                       std::string* serialized_value) {
+    DynamicMessageFactory factory;
+    const Message* value_prototype = factory.GetPrototype(value_descriptor);
+    if (value_prototype == nullptr) {
+      return false;
+    }
+    std::unique_ptr<Message> value(value_prototype->New());
+    std::string sub_delimiter;
+    DO(ConsumeMessageDelimiter(&sub_delimiter));
+    DO(ConsumeMessage(value.get(), sub_delimiter));
+
+    if (allow_partial_) {
+      // TODO: Remove this suppression.
+      (void)value->AppendPartialToString(serialized_value);
+    } else {
+      if (!value->IsInitialized()) {
+        std::vector<std::string> missing_fields;
+        value->FindInitializationErrors(&missing_fields);
+        ReportError(absl::StrCat(
+            "Value of type \"", value_descriptor->full_name(),
+            "\" stored in google.protobuf.Any has missing required fields: ",
+            absl::StrJoin(missing_fields, ", ")));
+        return false;
+      }
+      // TODO: Remove this suppression.
+      (void)value->AppendToString(serialized_value);
+    }
+    return true;
+  }
+
+  // Consumes a token and confirms that it matches that specified in the
+  // value parameter. Returns false if the token found does not match that
+  // which was specified.
+  bool Consume(const std::string& value) {
+    const std::string& current_value = tokenizer_.current().text;
+
+    if (current_value != value) {
+      ReportError(absl::StrCat("Expected \"", value, "\", found \"",
+                               current_value, "\"."));
+      return false;
+    }
+
+    tokenizer_.Next();
+
+    return true;
+  }
+
+  // Similar to `Consume`, but the following token may be tokenized as
+  // TYPE_WHITESPACE.
+  bool ConsumeBeforeWhitespace(const std::string& value) {
+    // Report whitespace after this token, but only once.
+    tokenizer_.set_report_whitespace(true);
+    bool result = Consume(value);
+    tokenizer_.set_report_whitespace(false);
+    return result;
+  }
+
+  // Attempts to consume the supplied value. Returns false if the token found
+  // does not match the value specified.
+  bool TryConsume(const std::string& value) {
+    if (tokenizer_.current().text == value) {
+      tokenizer_.Next();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // Similar to `TryConsume`, but the following token may be tokenized as
+  // TYPE_WHITESPACE.
+  bool TryConsumeBeforeWhitespace(const std::string& value) {
+    // Report whitespace after this token, but only once.
+    tokenizer_.set_report_whitespace(true);
+    bool result = TryConsume(value);
+    tokenizer_.set_report_whitespace(false);
+    return result;
+  }
+
+  bool TryConsumeWhitespace() {
+    had_silent_marker_ = false;
+    if (LookingAtType(io::Tokenizer::TYPE_WHITESPACE)) {
+      if (tokenizer_.current().text ==
+          absl::StrCat(" ", internal::kDebugStringSilentMarkerForDetection)) {
+        had_silent_marker_ = true;
+      }
+      tokenizer_.Next();
+      return true;
+    }
+    return false;
+  }
+
+  // An internal instance of the Tokenizer's error collector, used to
+  // collect any base-level parse errors and feed them to the ParserImpl.
+  class ParserErrorCollector : public io::ErrorCollector {
+   public:
+    explicit ParserErrorCollector(TextFormat::Parser::ParserImpl* parser)
+        : parser_(parser) {}
+
+    ParserErrorCollector(const ParserErrorCollector&) = delete;
+    ParserErrorCollector& operator=(const ParserErrorCollector&) = delete;
+    ~ParserErrorCollector() override = default;
+
+    void RecordError(int line, int column, absl::string_view message) override {
+      parser_->ReportError(line, column, message);
+    }
+
+    void RecordWarning(int line, int column,
+                       absl::string_view message) override {
+      parser_->ReportWarning(line, column, message);
+    }
+
+   private:
+    TextFormat::Parser::ParserImpl* parser_;
+  };
+
+  io::ErrorCollector* error_collector_;
+  const TextFormat::Finder* finder_;
+  ParseInfoTree* parse_info_tree_;
+  ParserErrorCollector tokenizer_error_collector_;
+  io::Tokenizer tokenizer_;
+  const Descriptor* root_message_type_;
+  SingularOverwritePolicy singular_overwrite_policy_;
+  const bool allow_case_insensitive_field_;
+  const bool allow_unknown_field_;
+  const bool allow_unknown_extension_;
+  const bool allow_unknown_enum_;
+  const bool allow_field_number_;
+  const bool allow_partial_;
+  const int initial_recursion_limit_;
+  int recursion_limit_;
+  bool had_silent_marker_;
+  bool had_errors_;
+  UnsetFieldsMetadata* no_op_fields_{};
+
+};
+
+// ===========================================================================
+// Internal class for writing text to the io::ZeroCopyOutputStream. Adapted
+// from the Printer found in //third_party/protobuf/io/printer.h
+class TextFormat::Printer::TextGenerator
+    : public TextFormat::BaseTextGenerator {
+ public:
+  explicit TextGenerator(io::ZeroCopyOutputStream* output,
+                         int initial_indent_level)
+      : output_(output),
+        buffer_(nullptr),
+        buffer_size_(0),
+        at_start_of_line_(true),
+        failed_(false),
+        insert_silent_marker_(false),
+        indent_level_(initial_indent_level),
+        initial_indent_level_(initial_indent_level) {}
+
+  explicit TextGenerator(io::ZeroCopyOutputStream* output,
+                         bool insert_silent_marker, int initial_indent_level)
+      : output_(output),
+        buffer_(nullptr),
+        buffer_size_(0),
+        at_start_of_line_(true),
+        failed_(false),
+        insert_silent_marker_(insert_silent_marker),
+        indent_level_(initial_indent_level),
+        initial_indent_level_(initial_indent_level) {}
+
+  TextGenerator(const TextGenerator&) = delete;
+  TextGenerator& operator=(const TextGenerator&) = delete;
+  ~TextGenerator() override {
+    // Only BackUp() if we're sure we've successfully called Next() at least
+    // once.
+    if (!failed_) {
+      output_->BackUp(buffer_size_);
+    }
+  }
+
+  // Indent text by two spaces.  After calling Indent(), two spaces will be
+  // inserted at the beginning of each line of text.  Indent() may be called
+  // multiple times to produce deeper indents.
+  void Indent() override { ++indent_level_; }
+
+  // Reduces the current indent level by two spaces, or crashes if the indent
+  // level is zero.
+  void Outdent() override {
+    if (indent_level_ == 0 || indent_level_ < initial_indent_level_) {
+      ABSL_DLOG(FATAL) << " Outdent() without matching Indent().";
+      return;
+    }
+
+    --indent_level_;
+  }
+
+  size_t GetCurrentIndentationSize() const override {
+    return 2 * indent_level_;
+  }
+
+  // Print text to the output stream.
+  void Print(const char* text, size_t size) override {
+    if (indent_level_ > 0) {
+      size_t pos = 0;  // The number of bytes we've written so far.
+      for (size_t i = 0; i < size; i++) {
+        if (text[i] == '\n') {
+          // Saw newline.  If there is more text, we may need to insert an
+          // indent here.  So, write what we have so far, including the '\n'.
+          Write(text + pos, i - pos + 1);
+          pos = i + 1;
+
+          // Setting this true will cause the next Write() to insert an indent
+          // first.
+          at_start_of_line_ = true;
+        }
+      }
+      // Write the rest.
+      Write(text + pos, size - pos);
+    } else {
+      Write(text, size);
+      if (size > 0 && text[size - 1] == '\n') {
+        at_start_of_line_ = true;
+      }
+    }
+  }
+
+  // True if any write to the underlying stream failed.  (We don't just
+  // crash in this case because this is an I/O failure, not a programming
+  // error.)
+  bool failed() const { return failed_; }
+
+  void PrintMaybeWithMarker(MarkerToken, absl::string_view text) override {
+    Print(text.data(), text.size());
+    if (ConsumeInsertSilentMarker()) {
+      PrintLiteral(internal::kDebugStringSilentMarker);
+    }
+  }
+
+  void PrintMaybeWithMarker(MarkerToken, absl::string_view text_head,
+                            absl::string_view text_tail) override {
+    Print(text_head.data(), text_head.size());
+    if (ConsumeInsertSilentMarker()) {
+      PrintLiteral(internal::kDebugStringSilentMarker);
+    }
+    Print(text_tail.data(), text_tail.size());
+  }
+
+ private:
+  void Write(const char* data, size_t size) {
+    if (failed_) return;
+    if (size == 0) return;
+
+    if (at_start_of_line_) {
+      // Insert an indent.
+      at_start_of_line_ = false;
+      WriteIndent();
+      if (failed_) return;
+    }
+
+    while (static_cast<int64_t>(size) > buffer_size_) {
+      // Data exceeds space in the buffer.  Copy what we can and request a
+      // new buffer.
+      if (buffer_size_ > 0) {
+        memcpy(buffer_, data, buffer_size_);
+        data += buffer_size_;
+        size -= buffer_size_;
+      }
+      void* void_buffer = nullptr;
+      failed_ = !output_->Next(&void_buffer, &buffer_size_);
+      if (failed_) return;
+      buffer_ = reinterpret_cast<char*>(void_buffer);
+    }
+
+    // Buffer is big enough to receive the data; copy it.
+    memcpy(buffer_, data, size);
+    buffer_ += size;
+    buffer_size_ -= size;
+  }
+
+  void WriteIndent() {
+    if (indent_level_ == 0) {
+      return;
+    }
+    ABSL_DCHECK(!failed_);
+    int size = GetCurrentIndentationSize();
+
+    while (size > buffer_size_) {
+      // Data exceeds space in the buffer. Write what we can and request a new
+      // buffer.
+      if (buffer_size_ > 0) {
+        memset(buffer_, ' ', buffer_size_);
+      }
+      size -= buffer_size_;
+      void* void_buffer;
+      failed_ = !output_->Next(&void_buffer, &buffer_size_);
+      if (failed_) return;
+      buffer_ = reinterpret_cast<char*>(void_buffer);
+    }
+
+    // Buffer is big enough to receive the data; copy it.
+    memset(buffer_, ' ', size);
+    buffer_ += size;
+    buffer_size_ -= size;
+  }
+
+  // Return the current value of insert_silent_marker_. If it is true, set it
+  // to false as we assume that a silent marker is inserted after a call to this
+  // function.
+  bool ConsumeInsertSilentMarker() {
+    if (insert_silent_marker_) {
+      insert_silent_marker_ = false;
+      return true;
+    }
+    return false;
+  }
+
+  io::ZeroCopyOutputStream* const output_;
+  char* buffer_;
+  int buffer_size_;
+  bool at_start_of_line_;
+  bool failed_;
+  // This flag is false when inserting silent marker is disabled or a silent
+  // marker has been inserted.
+  bool insert_silent_marker_;
+
+  int indent_level_;
+  int initial_indent_level_;
+};
+
+// ===========================================================================
+//  An internal field value printer that may insert a silent marker in
+//  DebugStrings.
+class TextFormat::Printer::DebugStringFieldValuePrinter
+    : public TextFormat::FastFieldValuePrinter {
+ public:
+  void PrintMessageStart(const Message& /*message*/, int /*field_index*/,
+                         int /*field_count*/, bool single_line_mode,
+                         BaseTextGenerator* generator) const override {
+    if (single_line_mode) {
+      generator->PrintMaybeWithMarker(MarkerToken(), " ", "{ ");
+    } else {
+      generator->PrintMaybeWithMarker(MarkerToken(), " ", "{\n");
+    }
+  }
+};
+
+namespace {
+
+// Returns true if `ch` needs to be escaped in TextFormat, independent of any
+// UTF-8 validity issues.
+bool DefinitelyNeedsEscape(unsigned char ch) {
+  if (ch >= 0x80) {
+    return false;  // High byte; no escapes necessary if UTF-8 is valid.
+  }
+
+  if (!absl::ascii_isprint(ch)) {
+    return true;  // Unprintable characters need escape.
+  }
+
+  switch (ch) {
+    case '\"':
+    case '\'':
+    case '\\':
+      // These characters need escapes despite being printable.
+      return true;
+  }
+
+  return false;
+}
+
+// Returns true if this is a high byte that requires UTF-8 validation.  If the
+// UTF-8 validation fails, we must escape the byte.
+bool NeedsUtf8Validation(unsigned char ch) { return ch > 127; }
+
+// Returns the number of bytes in the prefix of `val` that do not need escaping.
+// This is like utf8_range::SpanStructurallyValid(), except that it also
+// terminates at any ASCII char that needs to be escaped in TextFormat (any char
+// that has `DefinitelyNeedsEscape(ch) == true`).
+//
+// If we could get a variant of utf8_range::SpanStructurallyValid() that could
+// terminate on any of these chars, that might be more efficient, but it would
+// be much more complicated to modify that heavily SIMD code.
+size_t SkipPassthroughBytes(absl::string_view val) {
+  for (size_t i = 0; i < val.size(); i++) {
+    unsigned char uc = val[i];
+    if (DefinitelyNeedsEscape(uc)) return i;
+    if (NeedsUtf8Validation(uc)) {
+      // Find the end of this region of consecutive high bytes, so that we only
+      // give high bytes to the UTF-8 checker.  This avoids needing to perform
+      // a second scan of the ASCII characters looking for characters that
+      // need escaping.
+      //
+      // We assume that high bytes are less frequent than plain, printable ASCII
+      // bytes, so we accept the double-scan of high bytes.
+      size_t end = i + 1;
+      for (; end < val.size(); end++) {
+        if (!NeedsUtf8Validation(val[end])) break;
+      }
+      size_t n = end - i;
+      size_t ok = utf8_range::SpanStructurallyValid(val.substr(i, n));
+      if (ok != n) return i + ok;
+      i += ok - 1;
+    }
+  }
+  return val.size();
+}
+
+}  // namespace
+
+void TextFormat::Printer::HardenedPrintString(
+    absl::string_view src, TextFormat::BaseTextGenerator* generator) {
+  // Print as UTF-8, while guarding against any invalid UTF-8 in the string
+  // field.
+  //
+  // If in the future we have a guaranteed invariant that invalid UTF-8 will
+  // never be present, we could avoid the UTF-8 check here.
+
+  generator->PrintLiteral("\"");
+  while (!src.empty()) {
+    size_t n = SkipPassthroughBytes(src);
+    if (n != 0) {
+      generator->PrintString(src.substr(0, n));
+      src.remove_prefix(n);
+      if (src.empty()) break;
+    }
+
+    // If repeated calls to CEscape() and PrintString() are expensive, we could
+    // consider batching them, at the cost of some complexity.
+    generator->PrintString(absl::CEscape(src.substr(0, 1)));
+    src.remove_prefix(1);
+  }
+  generator->PrintLiteral("\"");
+}
+
+// ===========================================================================
+//  An internal field value printer that escape UTF8 strings.
+class TextFormat::Printer::FastFieldValuePrinterUtf8Escaping
+    : public TextFormat::Printer::DebugStringFieldValuePrinter {
+ public:
+  void PrintString(const std::string& val,
+                   TextFormat::BaseTextGenerator* generator) const override {
+    TextFormat::Printer::HardenedPrintString(val, generator);
+  }
+  void PrintBytes(const std::string& val,
+                  TextFormat::BaseTextGenerator* generator) const override {
+    return FastFieldValuePrinter::PrintString(val, generator);
+  }
+};
+
+// ===========================================================================
+// Implementation of the default Finder for extensions.
+TextFormat::Finder::~Finder() = default;
+
+const FieldDescriptor* TextFormat::Finder::FindExtension(
+    Message* message, const std::string& name) const {
+  return DefaultFinderFindExtension(message, name);
+}
+
+const FieldDescriptor* TextFormat::Finder::FindExtensionByNumber(
+    const Descriptor* descriptor, int number) const {
+  return DefaultFinderFindExtensionByNumber(descriptor, number);
+}
+
+const Descriptor* TextFormat::Finder::FindAnyType(
+    const Message& message, const std::string& url_prefix,
+    const std::string& name) const {
+  return DefaultFinderFindAnyType(message, url_prefix, name);
+}
+
+MessageFactory* TextFormat::Finder::FindExtensionFactory(
+    const FieldDescriptor* /*field*/) const {
+  return nullptr;
+}
+
+// ===========================================================================
+
+TextFormat::Parser::Parser()
+    : error_collector_(nullptr),
+      finder_(nullptr),
+      parse_info_tree_(nullptr),
+      allow_partial_(false),
+      allow_case_insensitive_field_(false),
+      allow_unknown_field_(false),
+      allow_unknown_extension_(false),
+      allow_unknown_enum_(false),
+      allow_field_number_(false),
+      allow_relaxed_whitespace_(false),
+      allow_singular_overwrites_(false),
+      recursion_limit_(std::numeric_limits<int>::max()) {}
+
+namespace {
+
+template <typename T>
+bool CheckParseInputSize(T& input, io::ErrorCollector* error_collector) {
+  if (input.size() > INT_MAX) {
+    error_collector->RecordError(
+        -1, 0,
+        absl::StrCat(
+            "Input size too large: ", static_cast<int64_t>(input.size()),
+            " bytes", " > ", INT_MAX, " bytes."));
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+bool TextFormat::Parser::Parse(io::ZeroCopyInputStream* input,
+                               Message* output) {
+  output->Clear();
+
+  ParserImpl::SingularOverwritePolicy overwrites_policy =
+      allow_singular_overwrites_ ? ParserImpl::ALLOW_SINGULAR_OVERWRITES
+                                 : ParserImpl::FORBID_SINGULAR_OVERWRITES;
+
+  ParserImpl parser(output->GetDescriptor(), input, error_collector_, finder_,
+                    parse_info_tree_, overwrites_policy,
+                    allow_case_insensitive_field_, allow_unknown_field_,
+                    allow_unknown_extension_, allow_unknown_enum_,
+                    allow_field_number_, allow_relaxed_whitespace_,
+                    allow_partial_, recursion_limit_, no_op_fields_);
+  return MergeUsingImpl(input, output, &parser);
+}
+
+bool TextFormat::Parser::ParseFromString(absl::string_view input,
+                                         Message* output) {
+  DO(CheckParseInputSize(input, error_collector_));
+  io::ArrayInputStream input_stream(input.data(), input.size());
+  return Parse(&input_stream, output);
+}
+
+bool TextFormat::Parser::ParseFromCord(const absl::Cord& input,
+                                       Message* output) {
+  DO(CheckParseInputSize(input, error_collector_));
+  io::CordInputStream input_stream(&input);
+  return Parse(&input_stream, output);
+}
+
+bool TextFormat::Parser::Merge(io::ZeroCopyInputStream* input,
+                               Message* output) {
+  ParserImpl parser(output->GetDescriptor(), input, error_collector_, finder_,
+                    parse_info_tree_, ParserImpl::ALLOW_SINGULAR_OVERWRITES,
+                    allow_case_insensitive_field_, allow_unknown_field_,
+                    allow_unknown_extension_, allow_unknown_enum_,
+                    allow_field_number_, allow_relaxed_whitespace_,
+                    allow_partial_, recursion_limit_, no_op_fields_);
+  return MergeUsingImpl(input, output, &parser);
+}
+
+bool TextFormat::Parser::MergeFromString(absl::string_view input,
+                                         Message* output) {
+  DO(CheckParseInputSize(input, error_collector_));
+  io::ArrayInputStream input_stream(input.data(), input.size());
+  return Merge(&input_stream, output);
+}
+
+bool TextFormat::Parser::MergeUsingImpl(io::ZeroCopyInputStream* /* input */,
+                                        Message* output,
+                                        ParserImpl* parser_impl) {
+  if (!parser_impl->Parse(output)) return false;
+  if (!allow_partial_ && !output->IsInitialized()) {
+    std::vector<std::string> missing_fields;
+    output->FindInitializationErrors(&missing_fields);
+    parser_impl->ReportError(-1, 0,
+                             absl::StrCat("Message missing required fields: ",
+                                          absl::StrJoin(missing_fields, ", ")));
+    return false;
+  }
+  return true;
+}
+
+bool TextFormat::Parser::ParseFieldValueFromString(absl::string_view input,
+                                                   const FieldDescriptor* field,
+                                                   Message* output) {
+  io::ArrayInputStream input_stream(input.data(), input.size());
+  ParserImpl parser(output->GetDescriptor(), &input_stream, error_collector_,
+                    finder_, parse_info_tree_,
+                    ParserImpl::ALLOW_SINGULAR_OVERWRITES,
+                    allow_case_insensitive_field_, allow_unknown_field_,
+                    allow_unknown_extension_, allow_unknown_enum_,
+                    allow_field_number_, allow_relaxed_whitespace_,
+                    allow_partial_, recursion_limit_, no_op_fields_);
+  return parser.ParseField(field, output);
+}
+
+/* static */ bool TextFormat::Parse(io::ZeroCopyInputStream* input,
+                                    Message* output) {
+  return Parser().Parse(input, output);
+}
+
+/* static */ bool TextFormat::Merge(io::ZeroCopyInputStream* input,
+                                    Message* output) {
+  return Parser().Merge(input, output);
+}
+
+/* static */ bool TextFormat::ParseFromString(absl::string_view input,
+                                              Message* output) {
+  return Parser().ParseFromString(input, output);
+}
+
+/* static */ bool TextFormat::ParseFromCord(const absl::Cord& input,
+                                            Message* output) {
+  return Parser().ParseFromCord(input, output);
+}
+
+/* static */ bool TextFormat::MergeFromString(absl::string_view input,
+                                              Message* output) {
+  return Parser().MergeFromString(input, output);
+}
+
+#undef DO
+
+// ===========================================================================
+
+TextFormat::BaseTextGenerator::~BaseTextGenerator() = default;
+
+namespace {
+
+// A BaseTextGenerator that writes to a string.
+class StringBaseTextGenerator : public TextFormat::BaseTextGenerator {
+ public:
+  void Print(const char* text, size_t size) override {
+    output_.append(text, size);
+  }
+
+  std::string Consume() && { return std::move(output_); }
+
+ private:
+  std::string output_;
+};
+
+}  // namespace
+
+// The default implementation for FieldValuePrinter. We just delegate the
+// implementation to the default FastFieldValuePrinter to avoid duplicating the
+// logic.
+TextFormat::FieldValuePrinter::FieldValuePrinter() = default;
+TextFormat::FieldValuePrinter::~FieldValuePrinter() {}
+
+#define FORWARD_IMPL(fn, ...)            \
+  StringBaseTextGenerator generator;     \
+  delegate_.fn(__VA_ARGS__, &generator); \
+  return std::move(generator).Consume()
+
+std::string TextFormat::FieldValuePrinter::PrintBool(bool val) const {
+  FORWARD_IMPL(PrintBool, val);
+}
+std::string TextFormat::FieldValuePrinter::PrintInt32(int32_t val) const {
+  FORWARD_IMPL(PrintInt32, val);
+}
+std::string TextFormat::FieldValuePrinter::PrintUInt32(uint32_t val) const {
+  FORWARD_IMPL(PrintUInt32, val);
+}
+std::string TextFormat::FieldValuePrinter::PrintInt64(int64_t val) const {
+  FORWARD_IMPL(PrintInt64, val);
+}
+std::string TextFormat::FieldValuePrinter::PrintUInt64(uint64_t val) const {
+  FORWARD_IMPL(PrintUInt64, val);
+}
+std::string TextFormat::FieldValuePrinter::PrintFloat(float val) const {
+  FORWARD_IMPL(PrintFloat, val);
+}
+std::string TextFormat::FieldValuePrinter::PrintDouble(double val) const {
+  FORWARD_IMPL(PrintDouble, val);
+}
+std::string TextFormat::FieldValuePrinter::PrintString(
+    const std::string& val) const {
+  FORWARD_IMPL(PrintString, val);
+}
+std::string TextFormat::FieldValuePrinter::PrintBytes(
+    const std::string& val) const {
+  return PrintString(val);
+}
+std::string TextFormat::FieldValuePrinter::PrintEnum(
+    int32_t val, const std::string& name) const {
+  FORWARD_IMPL(PrintEnum, val, name);
+}
+std::string TextFormat::FieldValuePrinter::PrintFieldName(
+    const Message& message, const Reflection* reflection,
+    const FieldDescriptor* field) const {
+  FORWARD_IMPL(PrintFieldName, message, reflection, field);
+}
+std::string TextFormat::FieldValuePrinter::PrintMessageStart(
+    const Message& message, int field_index, int field_count,
+    bool single_line_mode) const {
+  FORWARD_IMPL(PrintMessageStart, message, field_index, field_count,
+               single_line_mode);
+}
+std::string TextFormat::FieldValuePrinter::PrintMessageEnd(
+    const Message& message, int field_index, int field_count,
+    bool single_line_mode) const {
+  FORWARD_IMPL(PrintMessageEnd, message, field_index, field_count,
+               single_line_mode);
+}
+#undef FORWARD_IMPL
+
+TextFormat::FastFieldValuePrinter::FastFieldValuePrinter() = default;
+TextFormat::FastFieldValuePrinter::~FastFieldValuePrinter() = default;
+void TextFormat::FastFieldValuePrinter::PrintBool(
+    bool val, BaseTextGenerator* generator) const {
+  if (val) {
+    generator->PrintLiteral("true");
+  } else {
+    generator->PrintLiteral("false");
+  }
+}
+void TextFormat::FastFieldValuePrinter::PrintInt32(
+    int32_t val, BaseTextGenerator* generator) const {
+  generator->PrintString(absl::StrCat(val));
+}
+void TextFormat::FastFieldValuePrinter::PrintUInt32(
+    uint32_t val, BaseTextGenerator* generator) const {
+  generator->PrintString(absl::StrCat(val));
+}
+void TextFormat::FastFieldValuePrinter::PrintInt64(
+    int64_t val, BaseTextGenerator* generator) const {
+  generator->PrintString(absl::StrCat(val));
+}
+void TextFormat::FastFieldValuePrinter::PrintUInt64(
+    uint64_t val, BaseTextGenerator* generator) const {
+  generator->PrintString(absl::StrCat(val));
+}
+void TextFormat::FastFieldValuePrinter::PrintFloat(
+    float val, BaseTextGenerator* generator) const {
+  generator->PrintString(!std::isnan(val) ? io::SimpleFtoa(val) : "nan");
+}
+void TextFormat::FastFieldValuePrinter::PrintDouble(
+    double val, BaseTextGenerator* generator) const {
+  generator->PrintString(!std::isnan(val) ? io::SimpleDtoa(val) : "nan");
+}
+void TextFormat::FastFieldValuePrinter::PrintEnum(
+    int32_t /*val*/, const std::string& name,
+    BaseTextGenerator* generator) const {
+  generator->PrintString(name);
+}
+
+void TextFormat::FastFieldValuePrinter::PrintString(
+    const std::string& val, BaseTextGenerator* generator) const {
+  generator->PrintLiteral("\"");
+  if (!val.empty()) {
+    generator->PrintString(absl::CEscape(val));
+  }
+  generator->PrintLiteral("\"");
+}
+void TextFormat::FastFieldValuePrinter::PrintBytes(
+    const std::string& val, BaseTextGenerator* generator) const {
+  PrintString(val, generator);
+}
+void TextFormat::FastFieldValuePrinter::PrintFieldName(
+    const Message& message, int /*field_index*/, int /*field_count*/,
+    const Reflection* reflection, const FieldDescriptor* field,
+    BaseTextGenerator* generator) const {
+  PrintFieldName(message, reflection, field, generator);
+}
+void TextFormat::FastFieldValuePrinter::PrintFieldName(
+    const Message& /*message*/, const Reflection* /*reflection*/,
+    const FieldDescriptor* field, BaseTextGenerator* generator) const {
+  if (field->is_extension()) {
+    generator->PrintLiteral("[");
+    generator->PrintString(field->PrintableNameForExtension());
+    generator->PrintLiteral("]");
+  } else if (internal::cpp::IsGroupLike(*field)) {
+    // Groups must be serialized with their original capitalization.
+    generator->PrintString(field->message_type()->name());
+  } else {
+    generator->PrintString(field->name());
+  }
+}
+void TextFormat::FastFieldValuePrinter::PrintMessageStart(
+    const Message& /*message*/, int /*field_index*/, int /*field_count*/,
+    bool single_line_mode, BaseTextGenerator* generator) const {
+  if (single_line_mode) {
+    generator->PrintLiteral(" { ");
+  } else {
+    generator->PrintLiteral(" {\n");
+  }
+}
+bool TextFormat::FastFieldValuePrinter::PrintMessageContent(
+    const Message& /*message*/, int /*field_index*/, int /*field_count*/,
+    bool /*single_line_mode*/, BaseTextGenerator* /*generator*/) const {
+  return false;  // Use the default printing function.
+}
+void TextFormat::FastFieldValuePrinter::PrintMessageEnd(
+    const Message& /*message*/, int /*field_index*/, int /*field_count*/,
+    bool single_line_mode, BaseTextGenerator* generator) const {
+  if (single_line_mode) {
+    generator->PrintLiteral("} ");
+  } else {
+    generator->PrintLiteral("}\n");
+  }
+}
+
+namespace {
+
+// A legacy compatibility wrapper. Takes ownership of the delegate.
+class FieldValuePrinterWrapper : public TextFormat::FastFieldValuePrinter {
+ public:
+  explicit FieldValuePrinterWrapper(
+      const TextFormat::FieldValuePrinter* delegate)
+      : delegate_(delegate) {}
+
+  void SetDelegate(const TextFormat::FieldValuePrinter* delegate) {
+    delegate_.reset(delegate);
+  }
+
+  void PrintBool(bool val,
+                 TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintBool(val));
+  }
+  void PrintInt32(int32_t val,
+                  TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintInt32(val));
+  }
+  void PrintUInt32(uint32_t val,
+                   TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintUInt32(val));
+  }
+  void PrintInt64(int64_t val,
+                  TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintInt64(val));
+  }
+  void PrintUInt64(uint64_t val,
+                   TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintUInt64(val));
+  }
+  void PrintFloat(float val,
+                  TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintFloat(val));
+  }
+  void PrintDouble(double val,
+                   TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintDouble(val));
+  }
+  void PrintString(const std::string& val,
+                   TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintString(val));
+  }
+  void PrintBytes(const std::string& val,
+                  TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintBytes(val));
+  }
+  void PrintEnum(int32_t val, const std::string& name,
+                 TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintEnum(val, name));
+  }
+  void PrintFieldName(const Message& message, int /*field_index*/,
+                      int /*field_count*/, const Reflection* reflection,
+                      const FieldDescriptor* field,
+                      TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(
+        delegate_->PrintFieldName(message, reflection, field));
+  }
+  void PrintFieldName(const Message& message, const Reflection* reflection,
+                      const FieldDescriptor* field,
+                      TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(
+        delegate_->PrintFieldName(message, reflection, field));
+  }
+  void PrintMessageStart(
+      const Message& message, int field_index, int field_count,
+      bool single_line_mode,
+      TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintMessageStart(
+        message, field_index, field_count, single_line_mode));
+  }
+  void PrintMessageEnd(
+      const Message& message, int field_index, int field_count,
+      bool single_line_mode,
+      TextFormat::BaseTextGenerator* generator) const override {
+    generator->PrintString(delegate_->PrintMessageEnd(
+        message, field_index, field_count, single_line_mode));
+  }
+
+ private:
+  std::unique_ptr<const TextFormat::FieldValuePrinter> delegate_;
+};
+
+}  // namespace
+
+TextFormat::Printer::Printer()
+    : initial_indent_level_(0),
+      single_line_mode_(false),
+      use_field_number_(false),
+      use_short_repeated_primitives_(false),
+      insert_silent_marker_(false),
+      redact_debug_string_(false),
+      randomize_debug_string_(false),
+      report_sensitive_fields_(internal::FieldReporterLevel::kNoReport),
+      hide_unknown_fields_(false),
+      print_message_fields_in_index_order_(false),
+      expand_any_(false),
+      truncate_string_field_longer_than_(0LL),
+      finder_(nullptr) {
+  SetUseUtf8StringEscaping(false);
+}
+
+void TextFormat::Printer::SetUseUtf8StringEscaping(bool as_utf8) {
+  SetDefaultFieldValuePrinter(as_utf8 ? new FastFieldValuePrinterUtf8Escaping()
+                                      : new DebugStringFieldValuePrinter());
+}
+
+void TextFormat::Printer::SetDefaultFieldValuePrinter(
+    const FieldValuePrinter* printer) {
+  default_field_value_printer_ =
+      std::make_unique<FieldValuePrinterWrapper>(printer);
+}
+
+void TextFormat::Printer::SetDefaultFieldValuePrinter(
+    const FastFieldValuePrinter* printer) {
+  default_field_value_printer_.reset(printer);
+}
+
+bool TextFormat::Printer::RegisterFieldValuePrinter(
+    const FieldDescriptor* field, const FieldValuePrinter* printer) {
+  if (field == nullptr || printer == nullptr) {
+    return false;
+  }
+  std::unique_ptr<FieldValuePrinterWrapper> wrapper =
+      std::make_unique<FieldValuePrinterWrapper>(nullptr);
+  auto pair = custom_printers_.emplace(field, nullptr);
+  if (pair.second) {
+    wrapper->SetDelegate(printer);
+    pair.first->second = std::move(wrapper);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool TextFormat::Printer::RegisterFieldValuePrinter(
+    const FieldDescriptor* field, const FastFieldValuePrinter* printer) {
+  if (field == nullptr || printer == nullptr) {
+    return false;
+  }
+  auto pair = custom_printers_.emplace(field, nullptr);
+  if (pair.second) {
+    pair.first->second.reset(printer);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool TextFormat::Printer::RegisterMessagePrinter(
+    const Descriptor* descriptor, const MessagePrinter* printer) {
+  if (descriptor == nullptr || printer == nullptr) {
+    return false;
+  }
+  auto pair = custom_message_printers_.emplace(descriptor, nullptr);
+  if (pair.second) {
+    pair.first->second.reset(printer);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool TextFormat::Printer::PrintToString(const Message& message,
+                                        std::string* output) const {
+  ABSL_DCHECK(output) << "output specified is nullptr";
+
+  output->clear();
+  io::StringOutputStream output_stream(output);
+
+  return Print(message, &output_stream,
+               internal::FieldReporterLevel::kMemberPrintToString);
+}
+
+bool TextFormat::Printer::PrintUnknownFieldsToString(
+    const UnknownFieldSet& unknown_fields, std::string* output) const {
+  ABSL_DCHECK(output) << "output specified is nullptr";
+
+  output->clear();
+  io::StringOutputStream output_stream(output);
+  return PrintUnknownFields(unknown_fields, &output_stream);
+}
+
+bool TextFormat::Printer::Print(const Message& message,
+                                io::ZeroCopyOutputStream* output) const {
+  return Print(message, output, internal::FieldReporterLevel::kPrintWithStream);
+}
+
+bool TextFormat::Printer::Print(const Message& message,
+                                io::ZeroCopyOutputStream* output,
+                                internal::FieldReporterLevel reporter) const {
+  TextGenerator generator(output, insert_silent_marker_, initial_indent_level_);
+
+  internal::PrintTextMarker(&generator, redact_debug_string_,
+                            randomize_debug_string_, single_line_mode_);
+
+
+  Print(message, &generator);
+
+  // Output false if the generator failed internally.
+  return !generator.failed();
+}
+
+// Maximum recursion depth for heuristically printing out length-prefixed
+// unknown fields as messages.
+static constexpr int kUnknownFieldRecursionLimit = 10;
+
+bool TextFormat::Printer::PrintUnknownFields(
+    const UnknownFieldSet& unknown_fields,
+    io::ZeroCopyOutputStream* output) const {
+  TextGenerator generator(output, initial_indent_level_);
+
+  PrintUnknownFields(unknown_fields, &generator, kUnknownFieldRecursionLimit);
+
+  // Output false if the generator failed internally.
+  return !generator.failed();
+}
+
+namespace {
+// Comparison functor for sorting FieldDescriptors by field index.
+// Normal fields have higher precedence than extensions.
+struct FieldIndexSorter {
+  bool operator()(const FieldDescriptor* left,
+                  const FieldDescriptor* right) const {
+    if (left->is_extension() && right->is_extension()) {
+      return left->number() < right->number();
+    } else if (left->is_extension()) {
+      return false;
+    } else if (right->is_extension()) {
+      return true;
+    } else {
+      return left->index() < right->index();
+    }
+  }
+};
+
+}  // namespace
+
+bool TextFormat::Printer::PrintAny(const Message& message,
+                                   BaseTextGenerator* generator) const {
+  const FieldDescriptor* type_url_field;
+  const FieldDescriptor* value_field;
+  if (!internal::GetAnyFieldDescriptors(message, &type_url_field,
+                                        &value_field)) {
+    return false;
+  }
+
+  const Reflection* reflection = message.GetReflection();
+
+  // Extract the full type name from the type_url field.
+  const std::string& type_url = reflection->GetString(message, type_url_field);
+  std::string url_prefix;
+  std::string full_type_name;
+
+  if (!internal::ParseAnyTypeUrl(type_url, &url_prefix, &full_type_name)) {
+    return false;
+  }
+
+  // Print the "value" in text.
+  const Descriptor* value_descriptor =
+      finder_ ? finder_->FindAnyType(message, url_prefix, full_type_name)
+              : DefaultFinderFindAnyType(message, url_prefix, full_type_name);
+  if (value_descriptor == nullptr) {
+    ABSL_LOG(WARNING) << "Can't print proto content: proto type " << type_url
+                      << " not found";
+    return false;
+  }
+  DynamicMessageFactory factory;
+  std::unique_ptr<Message> value_message(
+      factory.GetPrototype(value_descriptor)->New());
+  std::string serialized_value = reflection->GetString(message, value_field);
+  if (!value_message->ParseFromString(serialized_value)) {
+    ABSL_LOG(WARNING) << type_url << ": failed to parse contents";
+    return false;
+  }
+  generator->PrintLiteral("[");
+  generator->PrintString(type_url);
+  generator->PrintLiteral("]");
+  const FastFieldValuePrinter* printer = GetFieldPrinter(value_field);
+  printer->PrintMessageStart(message, -1, 0, single_line_mode_, generator);
+  generator->Indent();
+  Print(*value_message, generator);
+  generator->Outdent();
+  printer->PrintMessageEnd(message, -1, 0, single_line_mode_, generator);
+  return true;
+}
+
+void TextFormat::Printer::Print(const Message& message,
+                                BaseTextGenerator* generator) const {
+  const Reflection* reflection = message.GetReflection();
+  if (!reflection) {
+    // This message does not provide any way to describe its structure.
+    // Parse it again in an UnknownFieldSet, and display this instead.
+    UnknownFieldSet unknown_fields;
+    {
+      std::string serialized = message.SerializeAsString();
+      io::ArrayInputStream input(serialized.data(), serialized.size());
+      // TODO: Remove this suppression.
+      (void)unknown_fields.ParseFromZeroCopyStream(&input);
+    }
+    PrintUnknownFields(unknown_fields, generator, kUnknownFieldRecursionLimit);
+    return;
+  }
+  const Descriptor* descriptor = message.GetDescriptor();
+  auto itr = custom_message_printers_.find(descriptor);
+  if (itr != custom_message_printers_.end()) {
+    itr->second->Print(message, single_line_mode_, generator);
+    return;
+  }
+  PrintMessage(message, generator);
+}
+
+void TextFormat::Printer::PrintMessage(const Message& message,
+                                       BaseTextGenerator* generator) const {
+  if (generator == nullptr) {
+    return;
+  }
+  const Descriptor* descriptor = message.GetDescriptor();
+  if (descriptor->full_name() == internal::kAnyFullTypeName && expand_any_ &&
+      PrintAny(message, generator)) {
+    return;
+  }
+  const Reflection* reflection = message.GetReflection();
+  std::vector<const FieldDescriptor*> fields;
+  if (descriptor->options().map_entry()) {
+    fields.push_back(descriptor->field(0));
+    fields.push_back(descriptor->field(1));
+  } else {
+    reflection->ListFields(message, &fields);
+  }
+
+  if (print_message_fields_in_index_order_) {
+    std::sort(fields.begin(), fields.end(), FieldIndexSorter());
+  }
+  for (const FieldDescriptor* field : fields) {
+    PrintField(message, reflection, field, generator);
+  }
+  if (!hide_unknown_fields_) {
+    PrintUnknownFields(reflection->GetUnknownFields(message), generator,
+                       kUnknownFieldRecursionLimit);
+  }
+}
+
+void TextFormat::Printer::PrintFieldValueToString(const Message& message,
+                                                  const FieldDescriptor* field,
+                                                  int index,
+                                                  std::string* output) const {
+  ABSL_DCHECK(output) << "output specified is nullptr";
+
+  output->clear();
+  io::StringOutputStream output_stream(output);
+  TextGenerator generator(&output_stream, initial_indent_level_);
+
+  PrintFieldValue(message, message.GetReflection(), field, index, &generator);
+}
+
+class MapEntryMessageComparator {
+ public:
+  explicit MapEntryMessageComparator(const Descriptor* descriptor)
+      : field_(descriptor->field(0)) {}
+
+  bool operator()(const Message* a, const Message* b) {
+    const Reflection* reflection = a->GetReflection();
+    switch (field_->cpp_type()) {
+      case FieldDescriptor::CPPTYPE_BOOL: {
+        bool first = reflection->GetBool(*a, field_);
+        bool second = reflection->GetBool(*b, field_);
+        return first < second;
+      }
+      case FieldDescriptor::CPPTYPE_INT32: {
+        int32_t first = reflection->GetInt32(*a, field_);
+        int32_t second = reflection->GetInt32(*b, field_);
+        return first < second;
+      }
+      case FieldDescriptor::CPPTYPE_INT64: {
+        int64_t first = reflection->GetInt64(*a, field_);
+        int64_t second = reflection->GetInt64(*b, field_);
+        return first < second;
+      }
+      case FieldDescriptor::CPPTYPE_UINT32: {
+        uint32_t first = reflection->GetUInt32(*a, field_);
+        uint32_t second = reflection->GetUInt32(*b, field_);
+        return first < second;
+      }
+      case FieldDescriptor::CPPTYPE_UINT64: {
+        uint64_t first = reflection->GetUInt64(*a, field_);
+        uint64_t second = reflection->GetUInt64(*b, field_);
+        return first < second;
+      }
+      case FieldDescriptor::CPPTYPE_STRING: {
+        std::string first = reflection->GetString(*a, field_);
+        std::string second = reflection->GetString(*b, field_);
+        return first < second;
+      }
+      default:
+        ABSL_DLOG(FATAL) << "Invalid key for map field.";
+        return true;
+    }
+  }
+
+ private:
+  const FieldDescriptor* field_;
+};
+
+namespace internal {
+
+struct MapEntries {
+  std::vector<std::unique_ptr<const Message>> owned_entries;
+  std::vector<const Message*> all_entries;
+};
+
+class MapFieldPrinterHelper {
+ public:
+  // DynamicMapSorter::Sort cannot be used because it enforces syncing with
+  // repeated field.
+  static MapEntries SortMap(const Message& message,
+                            const Reflection* reflection,
+                            const FieldDescriptor* field);
+  static void CopyKey(const MapKey& key, Message* message,
+                      const FieldDescriptor* field_desc);
+  static void CopyValue(const MapValueConstRef& value, Message* message,
+                        const FieldDescriptor* field_desc);
+};
+
+MapEntries MapFieldPrinterHelper::SortMap(const Message& message,
+                                          const Reflection* reflection,
+                                          const FieldDescriptor* field) {
+  const MapFieldBase& base = *reflection->GetMapData(message, field);
+
+  std::vector<const Message*> all_entries;
+  std::vector<std::unique_ptr<const Message>> owned_entries;
+  if (base.IsRepeatedFieldValid()) {
+    const RepeatedPtrField<Message>& map_field =
+        reflection->GetRepeatedPtrFieldInternal<Message>(
+            message, field,
+            Reflection::GetRepeatedFieldIntent::kHiddenOrInternal);
+    all_entries.reserve(map_field.size());
+    for (int i = 0; i < map_field.size(); ++i) {
+      all_entries.push_back(
+          const_cast<RepeatedPtrField<Message>*>(&map_field)->Mutable(i));
+    }
+  } else {
+    // TODO: For performance, instead of creating map entry message
+    // for each element, just store map keys and sort them.
+    const Descriptor* map_entry_desc = field->message_type();
+    const Message* prototype =
+        reflection->GetMessageFactory()->GetPrototype(map_entry_desc);
+    all_entries.reserve(reflection->MapSize(message, field));
+    owned_entries.reserve(reflection->MapSize(message, field));
+    for (ConstMapIterator iter = reflection->ConstMapBegin(&message, field);
+         iter != reflection->ConstMapEnd(&message, field); ++iter) {
+      std::unique_ptr<Message> map_entry_message =
+          absl::WrapUnique(prototype->New());
+      CopyKey(iter.GetKey(), map_entry_message.get(), map_entry_desc->field(0));
+      CopyValue(iter.GetValueRef(), map_entry_message.get(),
+                map_entry_desc->field(1));
+      all_entries.push_back(map_entry_message.get());
+      owned_entries.push_back(std::move(map_entry_message));
+    }
+  }
+
+  std::stable_sort(all_entries.begin(), all_entries.end(),
+                   MapEntryMessageComparator(field->message_type()));
+  return {std::move(owned_entries), std::move(all_entries)};
+}
+
+void MapFieldPrinterHelper::CopyKey(const MapKey& key, Message* message,
+                                    const FieldDescriptor* field_desc) {
+  const Reflection* reflection = message->GetReflection();
+  switch (field_desc->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_DOUBLE:
+    case FieldDescriptor::CPPTYPE_FLOAT:
+    case FieldDescriptor::CPPTYPE_ENUM:
+    case FieldDescriptor::CPPTYPE_MESSAGE:
+      ABSL_LOG(ERROR) << "Not supported.";
+      break;
+    case FieldDescriptor::CPPTYPE_STRING:
+      reflection->SetString(message, field_desc,
+                            std::string(key.GetStringValue()));
+      return;
+    case FieldDescriptor::CPPTYPE_INT64:
+      reflection->SetInt64(message, field_desc, key.GetInt64Value());
+      return;
+    case FieldDescriptor::CPPTYPE_INT32:
+      reflection->SetInt32(message, field_desc, key.GetInt32Value());
+      return;
+    case FieldDescriptor::CPPTYPE_UINT64:
+      reflection->SetUInt64(message, field_desc, key.GetUInt64Value());
+      return;
+    case FieldDescriptor::CPPTYPE_UINT32:
+      reflection->SetUInt32(message, field_desc, key.GetUInt32Value());
+      return;
+    case FieldDescriptor::CPPTYPE_BOOL:
+      reflection->SetBool(message, field_desc, key.GetBoolValue());
+      return;
+  }
+}
+
+void MapFieldPrinterHelper::CopyValue(const MapValueConstRef& value,
+                                      Message* message,
+                                      const FieldDescriptor* field_desc) {
+  const Reflection* reflection = message->GetReflection();
+  switch (field_desc->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_DOUBLE:
+      reflection->SetDouble(message, field_desc, value.GetDoubleValue());
+      return;
+    case FieldDescriptor::CPPTYPE_FLOAT:
+      reflection->SetFloat(message, field_desc, value.GetFloatValue());
+      return;
+    case FieldDescriptor::CPPTYPE_ENUM:
+      reflection->SetEnumValue(message, field_desc, value.GetEnumValue());
+      return;
+    case FieldDescriptor::CPPTYPE_MESSAGE: {
+      Message* sub_message = value.GetMessageValue().New();
+      sub_message->CopyFrom(value.GetMessageValue());
+      reflection->SetAllocatedMessage(message, sub_message, field_desc);
+      return;
+    }
+    case FieldDescriptor::CPPTYPE_STRING:
+      reflection->SetString(message, field_desc,
+                            std::string(value.GetStringValue()));
+      return;
+    case FieldDescriptor::CPPTYPE_INT64:
+      reflection->SetInt64(message, field_desc, value.GetInt64Value());
+      return;
+    case FieldDescriptor::CPPTYPE_INT32:
+      reflection->SetInt32(message, field_desc, value.GetInt32Value());
+      return;
+    case FieldDescriptor::CPPTYPE_UINT64:
+      reflection->SetUInt64(message, field_desc, value.GetUInt64Value());
+      return;
+    case FieldDescriptor::CPPTYPE_UINT32:
+      reflection->SetUInt32(message, field_desc, value.GetUInt32Value());
+      return;
+    case FieldDescriptor::CPPTYPE_BOOL:
+      reflection->SetBool(message, field_desc, value.GetBoolValue());
+      return;
+  }
+}
+}  // namespace internal
+
+void TextFormat::Printer::PrintField(const Message& message,
+                                     const Reflection* reflection,
+                                     const FieldDescriptor* field,
+                                     BaseTextGenerator* generator) const {
+  if (use_short_repeated_primitives_ && field->is_repeated() &&
+      field->cpp_type() != FieldDescriptor::CPPTYPE_STRING &&
+      field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
+    PrintShortRepeatedField(message, reflection, field, generator);
+    return;
+  }
+
+  int count = 0;
+
+  if (field->is_repeated()) {
+    count = reflection->FieldSize(message, field);
+  } else if (reflection->HasField(message, field) ||
+             field->containing_type()->options().map_entry()) {
+    count = 1;
+  }
+
+  bool is_map = field->is_map();
+  const internal::MapEntries map_entries =
+      is_map
+          ? internal::MapFieldPrinterHelper::SortMap(message, reflection, field)
+          : internal::MapEntries();
+
+  for (int j = 0; j < count; ++j) {
+    const int field_index = field->is_repeated() ? j : -1;
+
+    PrintFieldName(message, field_index, count, reflection, field, generator);
+
+    if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+      if (TryRedactFieldValue(message, field, generator,
+                              /*insert_value_separator=*/true)) {
+        break;
+      }
+      const FastFieldValuePrinter* printer = GetFieldPrinter(field);
+      const Message& sub_message =
+          field->is_repeated()
+              ? (is_map ? *map_entries.all_entries[j]
+                        : reflection->GetRepeatedMessage(message, field, j))
+              : reflection->GetMessage(message, field);
+      printer->PrintMessageStart(sub_message, field_index, count,
+                                 single_line_mode_, generator);
+      generator->Indent();
+      if (!printer->PrintMessageContent(sub_message, field_index, count,
+                                        single_line_mode_, generator)) {
+        Print(sub_message, generator);
+      }
+      generator->Outdent();
+      printer->PrintMessageEnd(sub_message, field_index, count,
+                               single_line_mode_, generator);
+    } else {
+      generator->PrintMaybeWithMarker(MarkerToken(), ": ");
+      // Write the field value.
+      PrintFieldValue(message, reflection, field, field_index, generator);
+      if (single_line_mode_) {
+        generator->PrintLiteral(" ");
+      } else {
+        generator->PrintLiteral("\n");
+      }
+    }
+  }
+}
+
+void TextFormat::Printer::PrintShortRepeatedField(
+    const Message& message, const Reflection* reflection,
+    const FieldDescriptor* field, BaseTextGenerator* generator) const {
+  // Print primitive repeated field in short form.
+  int size = reflection->FieldSize(message, field);
+  PrintFieldName(message, /*field_index=*/-1, /*field_count=*/size, reflection,
+                 field, generator);
+  generator->PrintMaybeWithMarker(MarkerToken(), ": ", "[");
+  for (int i = 0; i < size; i++) {
+    if (i > 0) generator->PrintLiteral(", ");
+    PrintFieldValue(message, reflection, field, i, generator);
+  }
+  if (single_line_mode_) {
+    generator->PrintLiteral("] ");
+  } else {
+    generator->PrintLiteral("]\n");
+  }
+}
+
+void TextFormat::Printer::PrintFieldName(const Message& message,
+                                         int field_index, int field_count,
+                                         const Reflection* reflection,
+                                         const FieldDescriptor* field,
+                                         BaseTextGenerator* generator) const {
+  // if use_field_number_ is true, prints field number instead
+  // of field name.
+  if (use_field_number_) {
+    generator->PrintString(absl::StrCat(field->number()));
+    return;
+  }
+
+  const FastFieldValuePrinter* printer = GetFieldPrinter(field);
+  printer->PrintFieldName(message, field_index, field_count, reflection, field,
+                          generator);
+}
+
+void TextFormat::Printer::PrintFieldValue(const Message& message,
+                                          const Reflection* reflection,
+                                          const FieldDescriptor* field,
+                                          int index,
+                                          BaseTextGenerator* generator) const {
+  ABSL_DCHECK(field->is_repeated() || (index == -1))
+      << "Index must be -1 for non-repeated fields";
+
+  const FastFieldValuePrinter* printer = GetFieldPrinter(field);
+  if (TryRedactFieldValue(message, field, generator,
+                          /*insert_value_separator=*/false)) {
+    return;
+  }
+
+  switch (field->cpp_type()) {
+#define OUTPUT_FIELD(CPPTYPE, METHOD)                                \
+  case FieldDescriptor::CPPTYPE_##CPPTYPE:                           \
+    printer->Print##METHOD(                                          \
+        field->is_repeated()                                         \
+            ? reflection->GetRepeated##METHOD(message, field, index) \
+            : reflection->Get##METHOD(message, field),               \
+        generator);                                                  \
+    break
+
+    OUTPUT_FIELD(INT32, Int32);
+    OUTPUT_FIELD(INT64, Int64);
+    OUTPUT_FIELD(UINT32, UInt32);
+    OUTPUT_FIELD(UINT64, UInt64);
+    OUTPUT_FIELD(FLOAT, Float);
+    OUTPUT_FIELD(DOUBLE, Double);
+    OUTPUT_FIELD(BOOL, Bool);
+#undef OUTPUT_FIELD
+
+    case FieldDescriptor::CPPTYPE_STRING: {
+      std::string scratch;
+      const std::string& value =
+          field->is_repeated()
+              ? reflection->GetRepeatedStringReference(message, field, index,
+                                                       &scratch)
+              : reflection->GetStringReference(message, field, &scratch);
+      const std::string* value_to_print = &value;
+      std::string truncated_value;
+      if (truncate_string_field_longer_than_ > 0 &&
+          static_cast<size_t>(truncate_string_field_longer_than_) <
+              value.size()) {
+        truncated_value = value.substr(0, truncate_string_field_longer_than_) +
+                          "...<truncated>...";
+        value_to_print = &truncated_value;
+      }
+      if (field->type() == FieldDescriptor::TYPE_STRING) {
+        printer->PrintString(*value_to_print, generator);
+      } else {
+        ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_BYTES);
+        printer->PrintBytes(*value_to_print, generator);
+      }
+      break;
+    }
+
+    case FieldDescriptor::CPPTYPE_ENUM: {
+      int enum_value =
+          field->is_repeated()
+              ? reflection->GetRepeatedEnumValue(message, field, index)
+              : reflection->GetEnumValue(message, field);
+      const EnumValueDescriptor* enum_desc =
+          field->enum_type()->FindValueByNumber(enum_value);
+      if (enum_desc != nullptr) {
+        printer->PrintEnum(enum_value, internal::NameOfEnumAsString(enum_desc),
+                           generator);
+      } else {
+        // Ordinarily, enum_desc should not be null, because proto2 has the
+        // invariant that set enum field values must be in-range, but with the
+        // new integer-based API for enums (or the RepeatedField<int> loophole),
+        // it is possible for the user to force an unknown integer value.  So we
+        // simply use the integer value itself as the enum value name in this
+        // case.
+        printer->PrintEnum(enum_value, absl::StrCat(enum_value), generator);
+      }
+      break;
+    }
+
+    case FieldDescriptor::CPPTYPE_MESSAGE:
+      Print(field->is_repeated()
+                ? reflection->GetRepeatedMessage(message, field, index)
+                : reflection->GetMessage(message, field),
+            generator);
+      break;
+  }
+}
+
+/* static */ bool TextFormat::Print(const Message& message,
+                                    io::ZeroCopyOutputStream* output) {
+  return Printer().Print(message, output);
+}
+
+/* static */ bool TextFormat::PrintUnknownFields(
+    const UnknownFieldSet& unknown_fields, io::ZeroCopyOutputStream* output) {
+  return Printer().PrintUnknownFields(unknown_fields, output);
+}
+
+/* static */ bool TextFormat::PrintToString(const Message& message,
+                                            std::string* output) {
+  auto printer = Printer();
+  return printer.PrintToString(message, output);
+}
+
+/* static */ bool TextFormat::PrintUnknownFieldsToString(
+    const UnknownFieldSet& unknown_fields, std::string* output) {
+  return Printer().PrintUnknownFieldsToString(unknown_fields, output);
+}
+
+/* static */ void TextFormat::PrintFieldValueToString(
+    const Message& message, const FieldDescriptor* field, int index,
+    std::string* output) {
+  return Printer().PrintFieldValueToString(message, field, index, output);
+}
+
+/* static */ bool TextFormat::ParseFieldValueFromString(
+    absl::string_view input, const FieldDescriptor* field, Message* message) {
+  return Parser().ParseFieldValueFromString(input, field, message);
+}
+
+template <typename... T>
+PROTOBUF_NOINLINE void TextFormat::OutOfLinePrintString(
+    BaseTextGenerator* generator, const T&... values) {
+  generator->PrintString(absl::StrCat(values...));
+}
+
+void TextFormat::Printer::PrintUnknownFields(
+    const UnknownFieldSet& unknown_fields, BaseTextGenerator* generator,
+    int recursion_budget) const {
+  for (int i = 0; i < unknown_fields.field_count(); i++) {
+    const UnknownField& field = unknown_fields.field(i);
+
+    switch (field.type()) {
+      case UnknownField::TYPE_VARINT:
+        OutOfLinePrintString(generator, field.number());
+        generator->PrintMaybeWithMarker(MarkerToken(), ": ");
+        if (redact_debug_string_) {
+          OutOfLinePrintString(generator, "UNKNOWN_VARINT ");
+          OutOfLinePrintString(generator, kFieldValueReplacement);
+        } else {
+          OutOfLinePrintString(generator, field.varint());
+        }
+        if (single_line_mode_) {
+          generator->PrintLiteral(" ");
+        } else {
+          generator->PrintLiteral("\n");
+        }
+        break;
+      case UnknownField::TYPE_FIXED32: {
+        OutOfLinePrintString(generator, field.number());
+        if (redact_debug_string_) {
+          generator->PrintMaybeWithMarker(MarkerToken(), ": ",
+                                          "UNKNOWN_FIXED32 ");
+          OutOfLinePrintString(generator, kFieldValueReplacement);
+        } else {
+          generator->PrintMaybeWithMarker(MarkerToken(), ": ", "0x");
+          OutOfLinePrintString(generator,
+                               absl::Hex(field.fixed32(), absl::kZeroPad8));
+        }
+        if (single_line_mode_) {
+          generator->PrintLiteral(" ");
+        } else {
+          generator->PrintLiteral("\n");
+        }
+        break;
+      }
+      case UnknownField::TYPE_FIXED64: {
+        OutOfLinePrintString(generator, field.number());
+        if (redact_debug_string_) {
+          generator->PrintMaybeWithMarker(MarkerToken(), ": ",
+                                          "UNKNOWN_FIXED64 ");
+          OutOfLinePrintString(generator, kFieldValueReplacement);
+        } else {
+          generator->PrintMaybeWithMarker(MarkerToken(), ": ", "0x");
+          OutOfLinePrintString(generator,
+                               absl::Hex(field.fixed64(), absl::kZeroPad16));
+        }
+        if (single_line_mode_) {
+          generator->PrintLiteral(" ");
+        } else {
+          generator->PrintLiteral("\n");
+        }
+        break;
+      }
+      case UnknownField::TYPE_LENGTH_DELIMITED: {
+        OutOfLinePrintString(generator, field.number());
+        const absl::string_view value = field.length_delimited();
+        // We create a CodedInputStream so that we can adhere to our recursion
+        // budget when we attempt to parse the data. UnknownFieldSet parsing is
+        // recursive because of groups.
+        io::CodedInputStream input_stream(
+            reinterpret_cast<const uint8_t*>(value.data()), value.size());
+        input_stream.SetRecursionLimit(recursion_budget);
+        UnknownFieldSet embedded_unknown_fields;
+        if (!value.empty() && recursion_budget > 0 &&
+            embedded_unknown_fields.ParseFromCodedStream(&input_stream)) {
+          // This field is parseable as a Message.
+          // It might not be a message, but in the case of ambiguity we assume
+          // it is a message.
+          if (redact_debug_string_) {
+            generator->PrintMaybeWithMarker(MarkerToken(), ": ",
+                                            "UNKNOWN_MESSAGE ");
+            OutOfLinePrintString(generator, kFieldValueReplacement);
+            if (single_line_mode_) {
+              generator->PrintLiteral(" ");
+            } else {
+              generator->PrintLiteral("\n");
+            }
+            break;
+          }
+          if (single_line_mode_) {
+            generator->PrintMaybeWithMarker(MarkerToken(), " ", "{ ");
+          } else {
+            generator->PrintMaybeWithMarker(MarkerToken(), " ", "{\n");
+            generator->Indent();
+          }
+          PrintUnknownFields(embedded_unknown_fields, generator,
+                             recursion_budget - 1);
+          if (single_line_mode_) {
+            generator->PrintLiteral("} ");
+          } else {
+            generator->Outdent();
+            generator->PrintLiteral("}\n");
+          }
+        } else {
+          // This field is not parseable as a Message (or we ran out of
+          // recursion budget). So it is probably just a plain string.
+          if (redact_debug_string_) {
+            generator->PrintMaybeWithMarker(MarkerToken(), ": ",
+                                            "UNKNOWN_STRING ");
+            OutOfLinePrintString(generator, kFieldValueReplacement);
+            if (single_line_mode_) {
+              generator->PrintLiteral(" ");
+            } else {
+              generator->PrintLiteral("\n");
+            }
+            break;
+          }
+          generator->PrintMaybeWithMarker(MarkerToken(), ": ", "\"");
+          generator->PrintString(absl::CEscape(value));
+          if (single_line_mode_) {
+            generator->PrintLiteral("\" ");
+          } else {
+            generator->PrintLiteral("\"\n");
+          }
+        }
+        break;
+      }
+      case UnknownField::TYPE_GROUP:
+        OutOfLinePrintString(generator, field.number());
+        if (redact_debug_string_) {
+          generator->PrintMaybeWithMarker(MarkerToken(), ": ",
+                                          "UNKNOWN_GROUP ");
+          OutOfLinePrintString(generator, kFieldValueReplacement);
+          if (single_line_mode_) {
+            generator->PrintLiteral(" ");
+          } else {
+            generator->PrintLiteral("\n");
+          }
+          break;
+        }
+        if (single_line_mode_) {
+          generator->PrintMaybeWithMarker(MarkerToken(), " ", "{ ");
+        } else {
+          generator->PrintMaybeWithMarker(MarkerToken(), " ", "{\n");
+          generator->Indent();
+        }
+        // For groups, we recurse without checking the budget. This is OK,
+        // because if the groups were too deeply nested then we would have
+        // already rejected the message when we originally parsed it.
+        PrintUnknownFields(field.group(), generator, recursion_budget - 1);
+        if (single_line_mode_) {
+          generator->PrintLiteral("} ");
+        } else {
+          generator->Outdent();
+          generator->PrintLiteral("}\n");
+        }
+        break;
+    }
+  }
+}
+
+// Traverse the tree of field options and check if any of them are sensitive.
+// We check for sensitive enum values in the options and in the fields of the
+// message-type options, recursively.
+TextFormat::RedactionState TextFormat::IsOptionSensitive(
+    const Message& opts, const Reflection* reflection,
+    const FieldDescriptor* option) {
+  if (option->type() == FieldDescriptor::TYPE_ENUM) {
+    auto count =
+        option->is_repeated() ? reflection->FieldSize(opts, option) : 1;
+    for (auto i = 0; i < count; i++) {
+      int enum_val = option->is_repeated()
+                         ? reflection->GetRepeatedEnumValue(opts, option, i)
+                         : reflection->GetEnumValue(opts, option);
+      const EnumValueDescriptor* option_value =
+          option->enum_type()->FindValueByNumber(enum_val);
+      if (option_value->options().debug_redact()) {
+        return TextFormat::RedactionState{true, false};
+      }
+    }
+  } else if (option->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+    auto count =
+        option->is_repeated() ? reflection->FieldSize(opts, option) : 1;
+    for (auto i = 0; i < count; i++) {
+      const Message& sub_message =
+          option->is_repeated()
+              ? reflection->GetRepeatedMessage(opts, option, i)
+              : reflection->GetMessage(opts, option);
+      const Reflection* sub_reflection = sub_message.GetReflection();
+      std::vector<const FieldDescriptor*> message_fields;
+      sub_reflection->ListFields(sub_message, &message_fields);
+      for (const FieldDescriptor* message_field : message_fields) {
+        auto result = TextFormat::IsOptionSensitive(sub_message, sub_reflection,
+                                                    message_field);
+        if (result.redact) {
+          return result;
+        }
+      }
+    }
+  }
+  return TextFormat::RedactionState{false, false};
+}
+
+TextFormat::RedactionState TextFormat::GetRedactionState(
+    const FieldDescriptor* field) {
+  auto options = field->options();
+  auto state = TextFormat::RedactionState{options.debug_redact(), false};
+  std::vector<const FieldDescriptor*> field_options;
+  const Reflection* reflection = options.GetReflection();
+  reflection->ListFields(options, &field_options);
+  for (const FieldDescriptor* option : field_options) {
+    auto result = TextFormat::IsOptionSensitive(options, reflection, option);
+    state = TextFormat::RedactionState{state.redact || result.redact,
+                                       state.report || result.report};
+  }
+  return state;
+}
+bool TextFormat::Printer::TryRedactFieldValue(
+    const Message& message, const FieldDescriptor* field,
+    BaseTextGenerator* generator, bool insert_value_separator) const {
+  TextFormat::RedactionState redaction_state =
+      DescriptorPool::MemoizeProjection(
+          field, [](const FieldDescriptor* field) {
+            return TextFormat::GetRedactionState(field);
+          });
+  if (redaction_state.redact) {
+    if (redact_debug_string_) {
+      IncrementRedactedFieldCounter();
+      if (insert_value_separator) {
+        generator->PrintMaybeWithMarker(MarkerToken(), ": ");
+      }
+      generator->PrintString(kFieldValueReplacement);
+      if (insert_value_separator) {
+        if (single_line_mode_) {
+          generator->PrintLiteral(" ");
+        } else {
+          generator->PrintLiteral("\n");
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+class TextMarkerGenerator final {
+ public:
+  static TextMarkerGenerator CreateRandom();
+
+  void PrintMarker(TextFormat::BaseTextGenerator* generator, bool redact,
+                   bool randomize, bool single_line_mode) const {
+    if (redact) {
+      generator->Print(redaction_marker_.data(), redaction_marker_.size());
+    }
+    if (randomize) {
+      generator->Print(random_marker_.data(), random_marker_.size());
+    }
+    if ((redact || randomize) && !single_line_mode) {
+      generator->PrintLiteral("\n");
+    }
+  }
+
+ private:
+  static constexpr absl::string_view kRedactionMarkers[] = {
+      "goo.gle/debugonly ", "goo.gle/debugstr ", "goo.gle/debugproto "};
+
+  static constexpr absl::string_view kRandomMarker = "   ";
+
+  static_assert(!kRandomMarker.empty(), "The random marker cannot be empty!");
+
+  constexpr TextMarkerGenerator(absl::string_view redaction_marker,
+                                absl::string_view random_marker)
+      : redaction_marker_(redaction_marker), random_marker_(random_marker) {}
+
+  absl::string_view redaction_marker_;
+  absl::string_view random_marker_;
+};
+
+TextMarkerGenerator TextMarkerGenerator::CreateRandom() {
+  // We avoid using sources backed by system entropy to allow the marker
+  // generator to work in sandboxed environments that have no access to syscalls
+  // such as getrandom or getpid. Note that this randomization has no security
+  // implications, it's only used to break code that attempts to deserialize
+  // debug strings.
+  std::mt19937_64 random{
+      static_cast<uint64_t>(absl::ToUnixMicros(absl::Now()))};
+
+  size_t redaction_marker_index = std::uniform_int_distribution<size_t>{
+      0, ABSL_ARRAYSIZE(kRedactionMarkers) - 1}(random);
+
+  size_t random_marker_size =
+      std::uniform_int_distribution<size_t>{1, kRandomMarker.size()}(random);
+
+  return TextMarkerGenerator(kRedactionMarkers[redaction_marker_index],
+                             kRandomMarker.substr(0, random_marker_size));
+}
+
+const TextMarkerGenerator& GetGlobalTextMarkerGenerator() {
+  static const TextMarkerGenerator kTextMarkerGenerator =
+      TextMarkerGenerator::CreateRandom();
+  return kTextMarkerGenerator;
+}
+
+namespace internal {
+void PrintTextMarker(TextFormat::BaseTextGenerator* generator, bool redact,
+                     bool randomize, bool single_line_mode) {
+  GetGlobalTextMarkerGenerator().PrintMarker(generator, redact, randomize,
+                                             single_line_mode);
+}
+}  // namespace internal
+
+}  // namespace protobuf
+}  // namespace google
+
+#include "google/protobuf/port_undef.inc"