Fix memoization key collision for function pointers.

PiperOrigin-RevId: 941306300

Author: sbenzaquen

src/google/protobuf/descriptor.h

@@ -2727,11 +2727,17 @@ class PROTOBUF_EXPORT DescriptorPool {
   static const auto& MemoizeProjection(const Desc* descriptor, Func func) {
     using ResultT = std::decay_t<decltype(func(descriptor))>;
     auto* pool = GetPool(descriptor);
-    static_assert(std::is_empty_v<Func> ||
-                  std::is_function_v<std::remove_pointer_t<Func>>);
-    // This static bool is unique per-Func, so its address can be used as a key.
-    static bool type_key;
-    auto key = std::pair<const void*, const void*>(descriptor, &type_key);
+    const void* secondary_key;
+    if constexpr (std::is_function_v<std::remove_pointer_t<Func>>) {
+      secondary_key = reinterpret_cast<const void*>(func);
+    } else if constexpr (std::is_empty_v<Func>) {
+      static bool type_key;
+      secondary_key = &type_key;
+    } else {
+      static_assert(sizeof(Func) == 0,
+                    "Func must be an empty functor or a function pointer.");
+    }
+    auto key = std::pair<const void*, const void*>(descriptor, secondary_key);
     {
       absl::ReaderMutexLock lock(&pool->field_memo_table_mutex_);
       auto it = pool->field_memo_table_->find(key);

src/google/protobuf/descriptor_unittest.cc

@@ -14375,6 +14375,34 @@ TEST_F(DescriptorPoolMemoizationTest, SupportsDifferentDescriptorTypes) {
   EXPECT_EQ(counter, 3);
 }
 
+// We define two helper functions with the exact same type signature
+// (absl::string_view(*)(const Descriptor*)) but different addresses.
+// We use them to test that MemoizeProjection does not cause key collisions
+// in the cache when passed different function pointers of the identical type.
+namespace {
+absl::string_view FunctionPointer1(const Descriptor* desc) {
+  return desc->name();
+}
+
+absl::string_view FunctionPointer2(const Descriptor* desc) {
+  return desc->full_name();
+}
+}  // namespace
+
+TEST_F(DescriptorPoolMemoizationTest, MemoizeProjectionFunctionPointers) {
+  const Descriptor* descriptor = proto2_unittest::TestAllTypes::descriptor();
+
+  const absl::string_view& res1 =
+      DescriptorPoolMemoizationTest::MemoizeProjection(descriptor,
+                                                       FunctionPointer1);
+  const absl::string_view& res2 =
+      DescriptorPoolMemoizationTest::MemoizeProjection(descriptor,
+                                                       FunctionPointer2);
+
+  EXPECT_EQ(res1, "TestAllTypes");
+  EXPECT_EQ(res2, "proto2_unittest.TestAllTypes");
+}
+
 TEST_F(DescriptorPoolMemoizationTest, MemoizeProjectionMultithreaded) {
   auto name_lambda = [](const FieldDescriptor* field) {
     return field->full_name();