Remove the three-arg Printer::Sub constructor and switch to the new AnnotatedAt().

PiperOrigin-RevId: 495078112

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

@@ -54,6 +54,8 @@ namespace protobuf {
 namespace compiler {
 namespace cpp {
 namespace {
+using Sub = ::google::protobuf::io::Printer::Sub;
+
 absl::flat_hash_map<absl::string_view, std::string> EnumVars(
     const EnumDescriptor* enum_, const Options& options,
     const EnumValueDescriptor* min, const EnumValueDescriptor* max) {
@@ -120,10 +122,12 @@ void EnumGenerator::GenerateDefinition(io::Printer* p) {
   auto v1 = p->WithVars(EnumVars(enum_, options_, limits_.min, limits_.max));
 
   auto v2 = p->WithVars({
-      {"Msg_Enum_Enum_MIN",
-       absl::StrCat(p->LookupVar("Msg_Enum_"), enum_->name(), "_MIN"), enum_},
-      {"Msg_Enum_Enum_MAX",
-       absl::StrCat(p->LookupVar("Msg_Enum_"), enum_->name(), "_MAX"), enum_},
+      Sub("Msg_Enum_Enum_MIN",
+          absl::StrCat(p->LookupVar("Msg_Enum_"), enum_->name(), "_MIN"))
+          .AnnotatedAs(enum_),
+      Sub("Msg_Enum_Enum_MAX",
+          absl::StrCat(p->LookupVar("Msg_Enum_"), enum_->name(), "_MAX"))
+          .AnnotatedAs(enum_),
   });
   p->Emit(
       {
@@ -133,12 +137,10 @@ void EnumGenerator::GenerateDefinition(io::Printer* p) {
                const auto* value = enum_->value(i);
                p->Emit(
                    {
-                       {
-                           "Msg_Enum_VALUE",
+                       Sub("Msg_Enum_VALUE",
                            absl::StrCat(p->LookupVar("Msg_Enum_"),
-                                        EnumValueName(value)),
-                           value,
-                       },
+                                        EnumValueName(value)))
+                           .AnnotatedAs(value),
                        {"kNumber", Int32ToString(value->number())},
                        {"DEPRECATED", value->options().deprecated()
                                           ? "PROTOBUF_DEPRECATED_ENUM"
@@ -151,7 +153,8 @@ void EnumGenerator::GenerateDefinition(io::Printer* p) {
            }},
           // Only emit annotations for the $Msg_Enum$ used in the `enum`
           // definition.
-          {"Msg_Enum_annotated", p->LookupVar("Msg_Enum"), enum_},
+          Sub("Msg_Enum_annotated", p->LookupVar("Msg_Enum"))
+              .AnnotatedAs(enum_),
           {"open_enum_sentinels",
            [&] {
              if (enum_->is_closed()) {
@@ -183,13 +186,13 @@ void EnumGenerator::GenerateDefinition(io::Printer* p) {
       )cc");
 
   if (generate_array_size_) {
-    p->Emit(
-        {{"Msg_Enum_Enum_ARRAYSIZE",
-          absl::StrCat(p->LookupVar("Msg_Enum_"), enum_->name(), "_ARRAYSIZE"),
-          enum_}},
-        R"cc(
-          constexpr int $Msg_Enum_Enum_ARRAYSIZE$ = $kMax$ + 1;
-        )cc");
+    p->Emit({Sub("Msg_Enum_Enum_ARRAYSIZE",
+                 absl::StrCat(p->LookupVar("Msg_Enum_"), enum_->name(),
+                              "_ARRAYSIZE"))
+                 .AnnotatedAs(enum_)},
+            R"cc(
+              constexpr int $Msg_Enum_Enum_ARRAYSIZE$ = $kMax$ + 1;
+            )cc");
   }
 
   if (has_reflection_) {
@@ -289,18 +292,15 @@ void EnumGenerator::GenerateGetEnumDescriptorSpecializations(io::Printer* p) {
 void EnumGenerator::GenerateSymbolImports(io::Printer* p) const {
   auto v = p->WithVars(EnumVars(enum_, options_, limits_.min, limits_.max));
 
-  {
-    auto a = p->WithVars({{"Enum_annotated", p->LookupVar("Enum_"), enum_}});
-    p->Emit(R"cc(
-      using $Enum_annotated$ = $Msg_Enum$;
-    )cc");
-  }
+  p->Emit({Sub("Enum_", p->LookupVar("Enum_")).AnnotatedAs(enum_)}, R"cc(
+    using $Enum_$ = $Msg_Enum$;
+  )cc");
 
   for (int j = 0; j < enum_->value_count(); ++j) {
     const auto* value = enum_->value(j);
     p->Emit(
         {
-            {"VALUE", EnumValueName(enum_->value(j)), value},
+            Sub("VALUE", EnumValueName(enum_->value(j))).AnnotatedAs(value),
             {"DEPRECATED",
              value->options().deprecated() ? "PROTOBUF_DEPRECATED_ENUM" : ""},
         },
@@ -311,8 +311,10 @@ void EnumGenerator::GenerateSymbolImports(io::Printer* p) const {
 
   p->Emit(
       {
-          {"Enum_MIN", absl::StrCat(enum_->name(), "_MIN"), enum_},
-          {"Enum_MAX", absl::StrCat(enum_->name(), "_MAX"), enum_},
+          Sub("Enum_MIN", absl::StrCat(enum_->name(), "_MIN"))
+              .AnnotatedAs(enum_),
+          Sub("Enum_MAX", absl::StrCat(enum_->name(), "_MAX"))
+              .AnnotatedAs(enum_),
       },
       R"cc(
         static inline bool $Enum$_IsValid(int value) {
@@ -324,7 +326,10 @@ void EnumGenerator::GenerateSymbolImports(io::Printer* p) const {
 
   if (generate_array_size_) {
     p->Emit(
-        {{"Enum_ARRAYSIZE", absl::StrCat(enum_->name(), "_ARRAYSIZE"), enum_}},
+        {
+            Sub("Enum_ARRAYSIZE", absl::StrCat(enum_->name(), "_ARRAYSIZE"))
+                .AnnotatedAs(enum_),
+        },
         R"cc(
           static constexpr int $Enum_ARRAYSIZE$ = $Msg_Enum$_$Enum$_ARRAYSIZE;
         )cc");

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

@@ -69,6 +69,8 @@ namespace protobuf {
 namespace compiler {
 namespace cpp {
 namespace {
+using Sub = ::google::protobuf::io::Printer::Sub;
+
 absl::flat_hash_map<absl::string_view, std::string> FileVars(
     const FileDescriptor* file, const Options& options) {
   return {
@@ -1121,7 +1123,7 @@ class FileGenerator::ForwardDeclarations {
 
   void Print(io::Printer* p, const Options& options) const {
     for (const auto& e : enums_) {
-      p->Emit({{"enum", e.first, e.second}}, R"cc(
+      p->Emit({Sub("enum", e.first).AnnotatedAs(e.second)}, R"cc(
         enum $enum$ : int;
         bool $enum$_IsValid(int value);
       )cc");
@@ -1131,7 +1133,7 @@ class FileGenerator::ForwardDeclarations {
       const Descriptor* desc = c.second;
       p->Emit(
           {
-              {"class", c.first, desc},
+              Sub("class", c.first).AnnotatedAs(desc),
               {"default_type", DefaultInstanceType(desc, options)},
               {"default_name", DefaultInstanceName(desc, options)},
           },

src/google/protobuf/io/printer.h

@@ -905,18 +905,7 @@ class Printer::Sub {
         value_(std::forward<Value>(value)),
         annotation_(absl::nullopt) {}
 
-  // NOTE: This is an overload rather than taking optional<AnnotationRecord>
-  // with a default argument of nullopt, because we want to pick up
-  // AnnotationRecord's user-defined conversions. Because going from
-  // e.g. Descriptor* -> optional<AnnotationRecord> requires two user-defined
-  // conversions, this does not work.
-  template <typename Key, typename Value>
-  Sub(Key&& key, Value&& value, AnnotationRecord annotation)
-      : key_(std::forward<Key>(key)),
-        value_(std::forward<Value>(value)),
-        annotation_(std::move(annotation)) {}
-
-  Sub Annotate(AnnotationRecord annotation) && {
+  Sub AnnotatedAs(AnnotationRecord annotation) && {
     annotation_ = std::move(annotation);
     return std::move(*this);
   }

src/google/protobuf/io/printer_unittest.cc

@@ -717,7 +717,9 @@ TEST_F(PrinterTest, EmitThreeArgWithVars) {
   FakeAnnotationCollector collector;
   {
     Printer printer(output(), '$', &collector);
-    auto v = printer.WithVars({{"class", "Foo", "file.proto"}});
+    auto v = printer.WithVars({
+        Printer::Sub("class", "Foo").AnnotatedAs("file.proto"),
+    });
 
     printer.Emit({{"f1", "x"}, {"f2", "y"}, {"f3", "z"}}, R"cc(
       class $class$ {