Merge pull request protocolbuffers#9525 from dlj-NaN/sync-stage

Integrate from Piper for C++, Java, and Python

CHANGES.txt

@@ -87,6 +87,7 @@ Unreleased Changes (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
   * Remove GetPointer() and explicit nullptr defaults.
   * add proto_h flag for speeding up large builds
   * Add missing overload for reference wrapped fields.
+  * Add MergedDescriptorDatabase::FindAllFileNames()
 
 
 2022-01-28 version 3.19.4 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)

src/google/protobuf/arenastring.h

@@ -228,8 +228,8 @@ static_assert(std::is_trivial<TaggedStringPtr>::value,
 // held, and the mutable and ownership invariants for each type.
 struct PROTOBUF_EXPORT ArenaStringPtr {
   ArenaStringPtr() = default;
-  explicit constexpr ArenaStringPtr(
-      ExplicitlyConstructedArenaString* default_value)
+  constexpr ArenaStringPtr(ExplicitlyConstructedArenaString* default_value,
+                           ConstantInitialized)
       : tagged_ptr_(default_value) {}
 
   // Called from generated code / reflection runtime only. Resets value to point

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

@@ -530,9 +530,11 @@ void StringFieldGenerator::GenerateConstinitInitializer(
     return;
   }
   if (descriptor_->default_value_string().empty()) {
-    format("$name$_(&::$proto_ns$::internal::fixed_address_empty_string)");
+    format(
+        "$name$_(&::_pbi::fixed_address_empty_string, "
+        "::_pbi::ConstantInitialized{})");
   } else {
-    format("$name$_(nullptr)");
+    format("$name$_(nullptr, ::_pbi::ConstantInitialized{})");
   }
 }
 

src/google/protobuf/descriptor_database.cc

@@ -34,6 +34,7 @@
 
 #include <google/protobuf/descriptor_database.h>
 
+#include <algorithm>
 #include <set>
 
 #include <google/protobuf/descriptor.pb.h>
@@ -1027,5 +1028,21 @@ bool MergedDescriptorDatabase::FindAllExtensionNumbers(
 }
 
 
+bool MergedDescriptorDatabase::FindAllFileNames(
+    std::vector<std::string>* output) {
+  bool implemented = false;
+  for (DescriptorDatabase* source : sources_) {
+    std::vector<std::string> source_output;
+    if (source->FindAllFileNames(&source_output)) {
+      output->reserve(output->size() + source_output.size());
+      for (auto& source : source_output) {
+        output->push_back(std::move(source));
+      }
+      implemented = true;
+    }
+  }
+  return implemented;
+}
+
 }  // namespace protobuf
 }  // namespace google

src/google/protobuf/descriptor_database.h

@@ -381,6 +381,10 @@ class PROTOBUF_EXPORT MergedDescriptorDatabase : public DescriptorDatabase {
                                std::vector<int>* output) override;
 
 
+  // This function is best-effort. Returns true if at least one underlying
+  // DescriptorDatabase returns true.
+  bool FindAllFileNames(std::vector<std::string>* output) override;
+
  private:
   std::vector<DescriptorDatabase*> sources_;
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MergedDescriptorDatabase);

src/google/protobuf/descriptor_database_unittest.cc

@@ -799,6 +799,13 @@ TEST_F(MergedDescriptorDatabaseTest, FindAllExtensionNumbers) {
   }
 }
 
+TEST_F(MergedDescriptorDatabaseTest, FindAllFileNames) {
+  std::vector<std::string> files;
+  EXPECT_TRUE(forward_merged_.FindAllFileNames(&files));
+  EXPECT_THAT(files, ::testing::UnorderedElementsAre("foo.proto", "bar.proto",
+                                                     "baz.proto", "baz.proto"));
+}
+
 
 }  // anonymous namespace
 }  // namespace protobuf

src/google/protobuf/map_field.h

@@ -338,7 +338,8 @@ class PROTOBUF_EXPORT MapFieldBase {
   // It uses a linker initialized mutex, so it is not compatible with regular
   // runtime instances.
   // Except in MSVC, where we can't have a constinit mutex.
-  explicit constexpr MapFieldBase(ConstantInitialized)
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  constexpr MapFieldBase(ConstantInitialized)
       : arena_(nullptr),
         repeated_field_(nullptr),
         mutex_(GOOGLE_PROTOBUF_LINKER_INITIALIZED),
@@ -497,7 +498,8 @@ class TypeDefinedMapFieldBase : public MapFieldBase {
   // This constructor is for constant initialized global instances.
   // It uses a linker initialized mutex, so it is not compatible with regular
   // runtime instances.
-  explicit constexpr TypeDefinedMapFieldBase(ConstantInitialized tag)
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  constexpr TypeDefinedMapFieldBase(ConstantInitialized tag)
       : MapFieldBase(tag) {}
   explicit TypeDefinedMapFieldBase(Arena* arena) : MapFieldBase(arena) {}
 
@@ -567,7 +569,8 @@ class MapField : public TypeDefinedMapFieldBase<Key, T> {
   // This constructor is for constant initialized global instances.
   // It uses a linker initialized mutex, so it is not compatible with regular
   // runtime instances.
-  explicit constexpr MapField(ConstantInitialized tag)
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  constexpr MapField(ConstantInitialized tag)
       : TypeDefinedMapFieldBase<Key, T>(tag), impl_() {}
   explicit MapField(Arena* arena)
       : TypeDefinedMapFieldBase<Key, T>(arena), impl_(arena) {}

src/google/protobuf/map_type_handler.h

@@ -591,7 +591,8 @@ inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::IsInitialized(
   constexpr auto                                                              \
   MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Constinit()         \
       ->TypeOnMemory {                                                        \
-    return TypeOnMemory(&internal::fixed_address_empty_string);               \
+    return TypeOnMemory(&internal::fixed_address_empty_string,                \
+                        ConstantInitialized{});                               \
   }                                                                           \
   template <typename Type>                                                    \
   inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,            \