Hide the synthetic MapEntry class in the pb.cc file.

This reduces the cost of including the headers.

COPYBARA_INTEGRATE_REVIEW=#28033 from yashanil98:fix/issue-10486-fatal-warnings-encode-decode d0bb423
FUTURE_COPYBARA_INTEGRATE_REVIEW=#28033 from yashanil98:fix/issue-10486-fatal-warnings-encode-decode d0bb423
PiperOrigin-RevId: 964912794

Author: sbenzaquen

src/google/protobuf/compiler/command_line_interface.cc

@@ -3284,7 +3284,9 @@ bool CommandLineInterface::EncodeOrDecode(const DescriptorPool* pool) {
     }
   }
 
+  bool found_warning = false;
   if (!message->IsInitialized()) {
+    found_warning = true;
     std::cerr << "warning:  Input message is missing required fields:  "
               << message->InitializationErrorString() << std::endl;
   }
@@ -3305,7 +3307,9 @@ bool CommandLineInterface::EncodeOrDecode(const DescriptorPool* pool) {
     }
   }
 
-  return true;
+  // Treat warnings as fatal when --fatal_warnings is set, after the output has
+  // been written so the behavior matches the compile path.
+  return !(fatal_warnings_ && found_warning);
 }
 
 bool CommandLineInterface::WriteDescriptorSet(

src/google/protobuf/compiler/command_line_interface_unittest.cc

@@ -6103,6 +6103,17 @@ TEST_P(EncodeDecodeTest, Partial) {
   ExpectWarning("warning:  Input message is missing required fields:  a, b, c");
 }
 
+TEST_P(EncodeDecodeTest, PartialWithFatalWarnings) {
+  RedirectStdinFromText("");
+  // With --fatal_warnings, the missing-required-fields warning must make protoc
+  // exit non-zero, while still emitting the warning and the output.
+  EXPECT_FALSE(
+      Run("google/protobuf/unittest.proto"
+          " --encode=proto2_unittest.TestRequired --fatal_warnings"));
+  ExpectStdoutMatchesText("");
+  ExpectWarning("warning:  Input message is missing required fields:  a, b, c");
+}
+
 TEST_P(EncodeDecodeTest, DecodeRaw) {
   proto2_unittest::TestAllTypes message;
   message.set_optional_int32(123);

src/google/protobuf/compiler/cpp/field_generators/map_field.cc

@@ -55,7 +55,6 @@ std::vector<Sub> Vars(const FieldDescriptor* field, const Options& opts,
   return {
       {"Map", absl::Substitute("::$2::Map<$0, $1>", key_type, val_type,
                                ProtobufNamespace(opts))},
-      {"Entry", ClassName(field->message_type(), false)},
       {"Key", PrimitiveTypeName(opts, key->cpp_type())},
       {"Val", val_type},
       {"MapField", lite ? "MapFieldLite" : "MapField"},
@@ -194,13 +193,16 @@ void Map::GeneratePrivateMembers(io::Printer* p) const {
           $pbi$::MapFieldLite<$Key$, $Val$> $name$_;
         )cc");
   } else {
-    p->Emit({{"kKeyType",
-              absl::AsciiStrToUpper(DeclaredTypeMethodName(key_->type()))},
-             {"kValType",
-              absl::AsciiStrToUpper(DeclaredTypeMethodName(val_->type()))}},
-            R"cc(
-              $pbi$::$MapField$<$Entry$, $Key$, $Val$> $name$_;
-            )cc");
+    p->Emit(
+        {{"globals", MsgGlobalsInstanceName(field_->message_type(), options_)},
+         {"kKeyType",
+          absl::AsciiStrToUpper(DeclaredTypeMethodName(key_->type()))},
+         {"kValType",
+          absl::AsciiStrToUpper(DeclaredTypeMethodName(val_->type()))}},
+        R"cc(
+          $pbi$::$MapField$<static_cast<const void*>(&$globals$), $Key$, $Val$>
+              $name$_;
+        )cc");
   }
 }
 

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

@@ -1414,9 +1414,6 @@ void MessageGenerator::GenerateMapEntryClassDefinition(io::Printer* p) {
                                    const $pbi$::ClassData* $nonnull$
                                        class_data);
           explicit $Msg$($pb$::Arena* $nullable$ arena);
-          static constexpr const void* $nonnull$ internal_message_globals() {
-            return &$globals$;
-          }
 
           $decl_verify_func$;
 
@@ -1731,7 +1728,6 @@ void MessageGenerator::GenerateClassDefinition(io::Printer* p) {
   Formatter format(p);
 
   if (IsMapEntryMessage(descriptor_)) {
-    GenerateMapEntryClassDefinition(p);
     return;
   }
 
@@ -5335,7 +5331,9 @@ void MessageGenerator::GenerateSourceDefaultInstance(io::Printer* p) {
   auto v = p->WithVars(ClassVars(descriptor_, options_));
   auto t = p->WithVars(MakeTrackerCalls(descriptor_, options_));
 
-  if (!IsMapEntryMessage(descriptor_)) {
+  if (IsMapEntryMessage(descriptor_)) {
+    GenerateMapEntryClassDefinition(p);
+  } else {
     p->Emit(
         {{"has_bit",
           [&] {

src/google/protobuf/map.h

@@ -74,9 +74,6 @@ template <typename Key, typename T>
 class MapFieldLite;
 class MapFieldBase;
 
-template <typename Derived, typename Key, typename T>
-class MapField;
-
 struct MapTestPeer;
 struct MapBenchmarkPeer;
 

src/google/protobuf/map_field.h

@@ -607,7 +607,7 @@ class TypeDefinedMapFieldBase : public MapFieldBase {
 // This class provides access to map field using generated api. It is used for
 // internal generated message implementation only. Users should never use this
 // directly.
-template <typename Derived, typename Key, typename T>
+template <const void* kGlobals, typename Key, typename T>
 class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED MapField final
     : public TypeDefinedMapFieldBase<Key, T> {
  public:
@@ -625,14 +625,12 @@ class PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED MapField final
   MapField(InternalVisibility, InternalMetadataOffset offset, Arena* arena,
            const MapField& from)
       : TypeDefinedMapFieldBase<Key, T>(
-            MessageGlobalsBase::ToDefaultInstance<Message>(
-                Derived::internal_message_globals()),
-            offset, arena, from) {}
+            MessageGlobalsBase::ToDefaultInstance<Message>(kGlobals), offset,
+            arena, from) {}
 
  private:
   explicit constexpr MapField(InternalMetadataOffset offset)
-      : MapField::TypeDefinedMapFieldBase(Derived::internal_message_globals(),
-                                          offset) {}
+      : MapField::TypeDefinedMapFieldBase(kGlobals, offset) {}
 
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
@@ -651,23 +649,23 @@ bool AllAreInitialized(const TypeDefinedMapFieldBase<Key, T>& field) {
   return true;
 }
 
-template <typename Derived, typename Key, typename T>
-using MapFieldWithArena = FieldWithArena<MapField<Derived, Key, T>>;
+template <const void* kGlobals, typename Key, typename T>
+using MapFieldWithArena = FieldWithArena<MapField<kGlobals, Key, T>>;
 
-template <typename Derived, typename Key, typename T>
-struct FieldArenaRep<MapField<Derived, Key, T>> {
-  using Type = MapFieldWithArena<Derived, Key, T>;
+template <const void* kGlobals, typename Key, typename T>
+struct FieldArenaRep<MapField<kGlobals, Key, T>> {
+  using Type = MapFieldWithArena<kGlobals, Key, T>;
 
-  static MapField<Derived, Key, T>* Get(Type* arena_rep) {
+  static MapField<kGlobals, Key, T>* Get(Type* arena_rep) {
     return &arena_rep->field();
   }
 };
 
-template <typename Derived, typename Key, typename T>
-struct FieldArenaRep<const MapField<Derived, Key, T>> {
-  using Type = const MapFieldWithArena<Derived, Key, T>;
+template <const void* kGlobals, typename Key, typename T>
+struct FieldArenaRep<const MapField<kGlobals, Key, T>> {
+  using Type = const MapFieldWithArena<kGlobals, Key, T>;
 
-  static const MapField<Derived, Key, T>* Get(Type* arena_rep) {
+  static const MapField<kGlobals, Key, T>* Get(Type* arena_rep) {
     return &arena_rep->field();
   }
 };
@@ -748,7 +746,7 @@ class PROTOBUF_EXPORT MapValueConstRef {
   FieldDescriptor::CppType type_;
 
  private:
-  template <typename Derived, typename K, typename V>
+  template <const void* kGlobals, typename K, typename V>
   friend class internal::MapField;
   template <typename K, typename V>
   friend class internal::TypeDefinedMapFieldBase;
@@ -852,7 +850,7 @@ class PROTOBUF_EXPORT MapIteratorBase {
  protected:
   template <typename Key, typename T>
   friend class internal::TypeDefinedMapFieldBase;
-  template <typename Derived, typename Key, typename T>
+  template <const void* kGlobals, typename Key, typename T>
   friend class internal::MapField;
   friend class internal::MapFieldBase;
 

src/google/protobuf/map_field_test.cc

@@ -44,13 +44,15 @@ struct MapFieldTestPeer {
   }
 };
 
-using TestMapField = ::google::protobuf::internal::MapField<
-    proto2_unittest::TestMap_MapInt32Int32Entry_DoNotUse, ::int32_t, ::int32_t>;
+constexpr const void* kEntryGlobals = static_cast<const void*>(
+    &proto2_unittest::TestMap_MapInt32Int32Entry_DoNotUse_globals_);
+
+using TestMapField =
+    ::google::protobuf::internal::MapField<kEntryGlobals, ::int32_t, ::int32_t>;
 
 class MapFieldBasePrimitiveTest : public testing::TestWithParam<bool> {
  protected:
-  typedef proto2_unittest::TestMap_MapInt32Int32Entry_DoNotUse EntryType;
-  typedef MapField<EntryType, int32_t, int32_t> MapFieldType;
+  typedef MapField<kEntryGlobals, int32_t, int32_t> MapFieldType;
 
   MapFieldBasePrimitiveTest()
       : arena_(GetParam() ? new Arena() : nullptr),
@@ -166,8 +168,7 @@ enum State { CLEAN, MAP_DIRTY, REPEATED_DIRTY };
 class MapFieldStateTest
     : public testing::TestWithParam<std::tuple<State, bool>> {
  protected:
-  typedef proto2_unittest::TestMap_MapInt32Int32Entry_DoNotUse EntryType;
-  typedef MapField<EntryType, int32_t, int32_t> MapFieldType;
+  typedef MapField<kEntryGlobals, int32_t, int32_t> MapFieldType;
   MapFieldStateTest()
       : arena_(std::get<1>(GetParam()) ? new Arena() : nullptr),
         map_field_(arena_.get()),
@@ -436,9 +437,7 @@ TEST_P(MapFieldStateTest, MutableMapField) {
   }
 }
 
-using MyMapField =
-    MapField<proto2_unittest::TestMap_MapInt32Int32Entry_DoNotUse, int32_t,
-             int32_t>;
+using MyMapField = MapField<kEntryGlobals, int32_t, int32_t>;
 
 TEST(MapFieldTest, ConstInit) {
   // This tests that `MapField` and all its base classes can be constant