Revert "SERVER-95859 Fix -Wmissing-prototypes warnings and enable it (#28170)" (#29184)

GitOrigin-RevId: 0c35f7647358a7e2116cbc4481996c524ff17409

Author: auto-revert-app[bot]

bazel/toolchains/mongo_cc_toolchain_config.bzl

@@ -687,27 +687,6 @@ def _impl(ctx):
         ],
     )
 
-    # Warn about global functions being defined without a definition, which
-    # usually indicates an unintentionally extern helper. Note that clang's
-    # `-Wmissing-declarations` is a very different warning.
-    if ctx.attr.compiler == "clang":
-        missing_proto_flag = [flag_group(flags = ["-Wmissing-prototypes"])]
-    elif ctx.attr.compiler == "gcc":
-        missing_proto_flag = [flag_group(flags = ["-Wmissing-declarations"])]
-    else:
-        missing_proto_flag = []
-
-    missing_prototypes_feature = feature(
-        name = "missing_prototypes_warning",
-        enabled = True,
-        flag_sets = [
-            flag_set(
-                actions = all_cpp_compile_actions,
-                flag_groups = missing_proto_flag,
-            ),
-        ],
-    )
-
     features = [
         bin_dirs_feature,
         default_compile_flags_feature,
@@ -746,7 +725,6 @@ def _impl(ctx):
         overloaded_virtual_warning_feature,
         no_overloaded_virtual_warning_feature,
         pessimizing_move_warning_feature,
-        missing_prototypes_feature,
     ]
 
     return [

src/SConscript

@@ -63,13 +63,8 @@ if env.ToolchainIs("gcc"):
     # With GCC, use the implicit fallthrough flag variant that doesn't
     # care about your feeble attempts to use comments to explain yourself.
     env.AddToCCFLAGSIfSupported("-Wimplicit-fallthrough=5")
-    env.AddToCCFLAGSIfSupported("-Wmissing-declarations")
 elif env.ToolchainIs("clang"):
     env.AddToCCFLAGSIfSupported("-Wimplicit-fallthrough")
-    # Clang's -Wmissing-prototypes is equivalent to GCC's
-    # -Wmissing-declarations, while Clang's -Wmissing-declarations checks
-    # something different.
-    env.AddToCCFLAGSIfSupported("-Wmissing-prototypes")
 
 # Run the core mongodb SConscript.
 env.SConscript("mongo/SConscript", must_exist=1, exports=["env"])

src/mongo/base/clonable_ptr_test.cpp

@@ -842,7 +842,6 @@ TEST(ClonablePtrTest, ownershipStabilityTest) {
     }
 }
 
-namespace {
 class ClonableObject {
 private:
     int value = 0;
@@ -868,7 +867,6 @@ bool operator==(const ClonableObject& lhs, const ClonableObject& rhs) {
 bool operator!=(const ClonableObject& lhs, const ClonableObject& rhs) {
     return !(lhs == rhs);
 }
-}  // namespace
 
 TEST(ClonablePtrTest, noObjectCopySemanticTest) {
     mongo::clonable_ptr<ClonableObject> p;

src/mongo/base/string_data_test.cpp

@@ -296,6 +296,16 @@ TEST(Rfind, Char1) {
     }
 }
 
+// this is to verify we match std::string
+void SUBSTR_TEST_HELP(StringData big, StringData small, size_t start, size_t len) {
+    ASSERT_EQUALS(small.toString(), big.toString().substr(start, len));
+    ASSERT_EQUALS(small, StringData(big).substr(start, len));
+}
+void SUBSTR_TEST_HELP(StringData big, StringData small, size_t start) {
+    ASSERT_EQUALS(small.toString(), big.toString().substr(start));
+    ASSERT_EQUALS(small, StringData(big).substr(start));
+}
+
 // [12] is number of args to substr
 #define SUBSTR_1_TEST_HELP(big, small, start)                                              \
     ASSERT_EQUALS(StringData(small).toString(), StringData(big).toString().substr(start)); \

src/mongo/bson/bson_bin_util.h

@@ -42,7 +42,7 @@
 namespace mongo {
 namespace bson_bin_util {
 
-inline std::string toHex(const char* data, std::size_t len) {
+std::string toHex(const char* data, std::size_t len) {
     auto rawString = mongo::StringData(data, len);
     std::ostringstream hexString;
     hexString << std::hex << std::uppercase;
@@ -53,15 +53,15 @@ inline std::string toHex(const char* data, std::size_t len) {
     return hexString.str();
 }
 
-inline std::string toHex(const BufBuilder& bldr) {
+std::string toHex(const BufBuilder& bldr) {
     return toHex(static_cast<const char*>(bldr.buf()), static_cast<std::size_t>(bldr.len()));
 }
 
-inline std::string toHex(const BSONBinData& binData) {
+std::string toHex(const BSONBinData& binData) {
     return toHex(static_cast<const char*>(binData.data), static_cast<std::size_t>(binData.length));
 }
 
-inline std::string toHex(const BSONObj& obj) {
+std::string toHex(const BSONObj& obj) {
     return toHex(obj.objdata(), static_cast<std::size_t>(obj.objsize()));
 }
 

src/mongo/bson/bson_bm.cpp

@@ -74,6 +74,7 @@ BSONObj buildSampleObj(long long unsigned int i) {
                        << "random" << random << "phone_no" << phone_no << "long_string"
                        << long_string);
 }
+}  // namespace
 
 void BM_arrayBuilder(benchmark::State& state) {
     size_t totalBytes = 0;
@@ -250,7 +251,6 @@ void BM_validate_contents(benchmark::State& state) {
     }
     state.SetBytesProcessed(totalSize);
 }
-}  // namespace
 
 BENCHMARK(BM_arrayBuilder)->Ranges({{{1}, {100'000}}});
 BENCHMARK(BM_arrayLookup)->Ranges({{{1}, {100'000}}});

src/mongo/bson/column/simple8b_bm.cpp

@@ -42,7 +42,6 @@
 #include "mongo/util/shared_buffer.h"
 
 namespace mongo {
-namespace {
 
 BufBuilder generateIntegers() {
     std::mt19937_64 seedGen(1337);
@@ -282,7 +281,6 @@ void BM_prefixSumUnoptimized(benchmark::State& state) {
 
     state.SetBytesProcessed(totalBytes);
 }
-}  // namespace
 
 BENCHMARK(BM_increasingValues)->Arg(100);
 BENCHMARK(BM_rle)->Arg(100);

src/mongo/bson/column/simple8b_type_util_test.cpp

@@ -43,7 +43,6 @@
 
 using namespace mongo;
 
-namespace {
 uint8_t scaleIndexForMultiplier(double multiplier) {
     auto iterIdx = std::find(Simple8bTypeUtil::kScaleMultiplier.begin(),
                              Simple8bTypeUtil::kScaleMultiplier.end(),
@@ -85,7 +84,6 @@ void assertStringEqual(StringData val, int128_t expected) {
     ASSERT_EQUALS(val.size(), decodeResult.size);
     ASSERT_EQUALS(std::memcmp(val.rawData(), decodeResult.str.data(), val.size()), 0);
 }
-}  // namespace
 
 TEST(Simple8bTypeUtil, EncodeAndDecodePositiveSignedInt) {
     int64_t signedVal = 1;

src/mongo/bson/mutable/mutable_bson_test.cpp

@@ -812,6 +812,22 @@ TEST(OIDType, nullOID) {
     ASSERT_EQUALS(withNull, recovered);
 }
 
+static const char jsonSample[] =
+    "{_id:ObjectId(\"47cc67093475061e3d95369d\"),"
+    "query:\"kate hudson\","
+    "owner:1234567887654321,"
+    "date:\"2011-05-13T14:22:46.777Z\","
+    "score:123.456,"
+    "field1:Infinity,"
+    "\"field2\":-Infinity,"
+    "\"field3\":NaN,"
+    "users:["
+    "{uname:\"@aaaa\",editid:\"123\",date:1303959350,yes_votes:0,no_votes:0},"
+    "{uname:\"@bbbb\",editid:\"456\",date:1303959350,yes_votes:0,no_votes:0},"
+    "{uname:\"@cccc\",editid:\"789\",date:1303959350,yes_votes:0,no_votes:0}],"
+    "pattern:/match.*this/,"
+    "lastfield:\"last\"}";
+
 static const char jsonSampleWithDecimal[] =
     "{_id:ObjectId(\"47cc67093475061e3d95369d\"),"
     "query:\"kate hudson\","

src/mongo/client/internal_auth.cpp

@@ -127,15 +127,14 @@ BSONObj getInternalAuthParams(size_t idx, StringData mechanism) {
                 << false);
 }
 
-namespace {
 std::string getBSONString(const BSONObj& container, StringData field) {
     auto elem = container[field];
     uassert(ErrorCodes::BadValue,
             str::stream() << "Field '" << field << "' must be of type string",
             elem.type() == String);
     return elem.String();
 }
-}  // namespace
+
 
 std::string getInternalAuthDB() {
     stdx::lock_guard<stdx::mutex> lk(internalAuthKeysMutex);

src/mongo/client/sdam/server_selection_json_test_runner.cpp

@@ -105,7 +105,7 @@ using namespace mongo::sdam;
 
 namespace mongo::sdam {
 
-static std::ostream& operator<<(std::ostream& os, const std::vector<HostAndPort>& input) {
+std::ostream& operator<<(std::ostream& os, const std::vector<HostAndPort>& input) {
     for (auto const& i : input) {
         os << i.toString() << " ";
     }

src/mongo/client/sdam/topology_description_test.cpp

@@ -56,7 +56,7 @@
 
 namespace mongo {
 
-static bool operator==(const TopologyVersion& a, const TopologyVersion& b) {
+bool operator==(const TopologyVersion& a, const TopologyVersion& b) {
     return a.getProcessId() == b.getProcessId() && a.getCounter() == b.getCounter();
 }
 

src/mongo/client/streamable_replica_set_monitor.cpp

@@ -93,6 +93,10 @@ bool maxWireCompare(const ServerDescriptionPtr& a, const ServerDescriptionPtr& b
     return a->getMaxWireVersion() < b->getMaxWireVersion();
 }
 
+bool secondaryPredicate(const ServerDescriptionPtr& server) {
+    return server->getType() == ServerType::kRSSecondary;
+}
+
 bool primaryOrSecondaryPredicate(const ServerDescriptionPtr& server) {
     const auto serverType = server->getType();
     return serverType == ServerType::kRSPrimary || serverType == ServerType::kRSSecondary;

src/mongo/crypto/fle_crypto.cpp

@@ -387,6 +387,13 @@ void toEncryptedBinData(StringData field,
     builder->appendBinData(field, buf.size(), BinDataType::Encrypt, buf.data());
 }
 
+std::pair<EncryptedBinDataType, ConstDataRange> fromEncryptedBinData(const BSONElement element) {
+    uassert(
+        6672414, "Expected binData with subtype Encrypt", element.isBinData(BinDataType::Encrypt));
+
+    return fromEncryptedConstDataRange(binDataToCDR(element));
+}
+
 template <FLETokenType TokenT>
 FLEToken<TokenT> FLETokenFromCDR(ConstDataRange cdr) {
     auto block = PrfBlockfromCDR(cdr);
@@ -425,6 +432,14 @@ StatusWith<std::vector<uint8_t>> encryptData(ConstDataRange key, ConstDataRange
     return {out};
 }
 
+StatusWith<std::vector<uint8_t>> encryptData(ConstDataRange key, uint64_t value) {
+
+    std::array<char, sizeof(uint64_t)> bufValue;
+    DataView(bufValue.data()).write<LittleEndian<uint64_t>>(value);
+
+    return encryptData(key, bufValue);
+}
+
 StatusWith<std::vector<uint8_t>> decryptDataWithAssociatedData(ConstDataRange key,
                                                                ConstDataRange associatedData,
                                                                ConstDataRange cipherText,
@@ -1451,6 +1466,21 @@ void collectIndexedFields(std::vector<EDCIndexedFields>* pFields,
     }
 }
 
+void collectFieldValidationInfo(stdx::unordered_map<std::string, ConstDataRange>* pFields,
+                                ConstDataRange cdr,
+                                StringData fieldPath) {
+    pFields->insert({fieldPath.toString(), cdr});
+}
+
+stdx::unordered_map<std::string, EncryptedField> toFieldMap(const EncryptedFieldConfig& efc) {
+    stdx::unordered_map<std::string, EncryptedField> fields;
+    for (const auto& field : efc.getFields()) {
+        fields.insert({field.getPath().toString(), field});
+    }
+
+    return fields;
+}
+
 uint64_t generateRandomContention(uint64_t cm) {
     // For non-contentious fields, we select the partition number, u, to be equal to 0.
     //
@@ -4171,7 +4201,6 @@ std::size_t Edges::size() const {
     return (_trimFactor == 0 ? 1 : 0) + edges;
 }
 
-namespace {
 template <typename T>
 std::unique_ptr<Edges> getEdgesT(
     T value, T min, T max, int sparsity, const boost::optional<int>& trimFactor) {
@@ -4187,7 +4216,6 @@ std::unique_ptr<Edges> getEdgesT(
     std::string valueBinTrimmed = valueBin.substr(bits - maxlen, maxlen);
     return std::make_unique<Edges>(valueBinTrimmed, sparsity, trimFactor);
 }
-}  // namespace
 
 std::unique_ptr<Edges> getEdgesInt32(int32_t value,
                                      boost::optional<int32_t> min,
@@ -4274,7 +4302,6 @@ std::uint64_t getEdgesLength(BSONType fieldType, StringData fieldPath, QueryType
     MONGO_UNREACHABLE;
 }
 
-namespace {
 template <typename T>
 class MinCoverGenerator {
 public:
@@ -4407,7 +4434,6 @@ void adjustBounds(T& lowerBound, bool includeLowerBound, T& upperBound, bool inc
         upperBound.value -= 1;
     }
 }
-}  // namespace
 
 std::vector<std::string> minCoverInt32(int32_t lowerBound,
                                        bool includeLowerBound,