SERVER-41772 Apply clang-format 7.0.1 to the codebase

23 files changed, 305 insertions, 423 deletions

diff --git a/src/mongo/s/catalog/dist_lock_catalog_impl.cpp b/src/mongo/s/catalog/dist_lock_catalog_impl.cpp
index 7a4b6e1564a..d8574212532 100644
--- a/src/mongo/s/catalog/dist_lock_catalog_impl.cpp
+++ b/src/mongo/s/catalog/dist_lock_catalog_impl.cpp
@@ -93,8 +93,7 @@ StatusWith<BSONObj> extractFindAndModifyNewObj(StatusWith<Shard::CommandResponse
             return {ErrorCodes::UnsupportedFormat,
                     str::stream() << "expected an object from the findAndModify response '"
                                   << kFindAndModifyResponseResultDocField
-                                  << "'field, got: "
-                                  << newDocElem};
+                                  << "'field, got: " << newDocElem};
         }
 
         return newDocElem.Obj().getOwned();
@@ -220,14 +219,10 @@ StatusWith<LocksType> DistLockCatalogImpl::grabLock(OperationContext* opCtx,
                                                     Date_t time,
                                                     StringData why,
                                                     const WriteConcernOptions& writeConcern) {
-    BSONObj newLockDetails(BSON(
-        LocksType::lockID(lockSessionID) << LocksType::state(LocksType::LOCKED) << LocksType::who()
-                                         << who
-                                         << LocksType::process()
-                                         << processId
-                                         << LocksType::when(time)
-                                         << LocksType::why()
-                                         << why));
+    BSONObj newLockDetails(BSON(LocksType::lockID(lockSessionID)
+                                << LocksType::state(LocksType::LOCKED) << LocksType::who() << who
+                                << LocksType::process() << processId << LocksType::when(time)
+                                << LocksType::why() << why));
 
     auto request = FindAndModifyRequest::makeUpdate(
         _locksNS,
@@ -281,14 +276,10 @@ StatusWith<LocksType> DistLockCatalogImpl::overtakeLock(OperationContext* opCtx,
         BSON(LocksType::name() << lockID << LocksType::state(LocksType::UNLOCKED)));
     orQueryBuilder.append(BSON(LocksType::name() << lockID << LocksType::lockID(currentHolderTS)));
 
-    BSONObj newLockDetails(BSON(
-        LocksType::lockID(lockSessionID) << LocksType::state(LocksType::LOCKED) << LocksType::who()
-                                         << who
-                                         << LocksType::process()
-                                         << processId
-                                         << LocksType::when(time)
-                                         << LocksType::why()
-                                         << why));
+    BSONObj newLockDetails(BSON(LocksType::lockID(lockSessionID)
+                                << LocksType::state(LocksType::LOCKED) << LocksType::who() << who
+                                << LocksType::process() << processId << LocksType::when(time)
+                                << LocksType::why() << why));
 
     auto request = FindAndModifyRequest::makeUpdate(
         _locksNS, BSON("$or" << orQueryBuilder.arr()), BSON("$set" << newLockDetails));
diff --git a/src/mongo/s/catalog/dist_lock_catalog_mock.cpp b/src/mongo/s/catalog/dist_lock_catalog_mock.cpp
index f2eca5abcf7..5dae286da5a 100644
--- a/src/mongo/s/catalog/dist_lock_catalog_mock.cpp
+++ b/src/mongo/s/catalog/dist_lock_catalog_mock.cpp
@@ -53,14 +53,8 @@ void noGrabLockFuncSet(StringData lockID,
                        Date_t time,
                        StringData why) {
     FAIL(str::stream() << "grabLock not expected to be called. "
-                       << "lockID: "
-                       << lockID
-                       << ", who: "
-                       << who
-                       << ", processId: "
-                       << processId
-                       << ", why: "
-                       << why);
+                       << "lockID: " << lockID << ", who: " << who << ", processId: " << processId
+                       << ", why: " << why);
 }
 
 void noOvertakeLockFuncSet(StringData lockID,
@@ -71,22 +65,13 @@ void noOvertakeLockFuncSet(StringData lockID,
                            Date_t time,
                            StringData why) {
     FAIL(str::stream() << "overtakeLock not expected to be called. "
-                       << "lockID: "
-                       << lockID
-                       << ", currentHolderTS: "
-                       << currentHolderTS
-                       << ", who: "
-                       << who
-                       << ", processId: "
-                       << processId
-                       << ", why: "
-                       << why);
+                       << "lockID: " << lockID << ", currentHolderTS: " << currentHolderTS
+                       << ", who: " << who << ", processId: " << processId << ", why: " << why);
 }
 
 void noUnLockFuncSet(const OID& lockSessionID) {
     FAIL(str::stream() << "unlock not expected to be called. "
-                       << "lockSessionID: "
-                       << lockSessionID);
+                       << "lockSessionID: " << lockSessionID);
 }
 
 void noPingFuncSet(StringData processID, Date_t ping) {
@@ -95,26 +80,22 @@ void noPingFuncSet(StringData processID, Date_t ping) {
 
 void noStopPingFuncSet(StringData processID) {
     FAIL(str::stream() << "stopPing not expected to be called. "
-                       << "processID: "
-                       << processID);
+                       << "processID: " << processID);
 }
 
 void noGetLockByTSSet(const OID& lockSessionID) {
     FAIL(str::stream() << "getLockByTS not expected to be called. "
-                       << "lockSessionID: "
-                       << lockSessionID);
+                       << "lockSessionID: " << lockSessionID);
 }
 
 void noGetLockByNameSet(StringData name) {
     FAIL(str::stream() << "getLockByName not expected to be called. "
-                       << "lockName: "
-                       << name);
+                       << "lockName: " << name);
 }
 
 void noGetPingSet(StringData processId) {
     FAIL(str::stream() << "getPing not expected to be called. "
-                       << "lockName: "
-                       << processId);
+                       << "lockName: " << processId);
 }
 
 void noGetServerInfoSet() {
diff --git a/src/mongo/s/catalog/dist_lock_catalog_mock.h b/src/mongo/s/catalog/dist_lock_catalog_mock.h
index 4fd6562cdc5..faae634b09e 100644
--- a/src/mongo/s/catalog/dist_lock_catalog_mock.h
+++ b/src/mongo/s/catalog/dist_lock_catalog_mock.h
@@ -220,4 +220,4 @@ private:
     GetServerInfoFunc _getServerInfoChecker;
     StatusWith<DistLockCatalog::ServerInfo> _getServerInfoReturnValue;
 };
-}
+}  // namespace mongo
diff --git a/src/mongo/s/catalog/dist_lock_manager_mock.cpp b/src/mongo/s/catalog/dist_lock_manager_mock.cpp
index ceb0611669b..6a17de30fad 100644
--- a/src/mongo/s/catalog/dist_lock_manager_mock.cpp
+++ b/src/mongo/s/catalog/dist_lock_manager_mock.cpp
@@ -45,12 +45,8 @@ namespace {
 
 void NoLockFuncSet(StringData name, StringData whyMessage, Milliseconds waitFor) {
     FAIL(str::stream() << "Lock not expected to be called. "
-                       << "Name: "
-                       << name
-                       << ", whyMessage: "
-                       << whyMessage
-                       << ", waitFor: "
-                       << waitFor);
+                       << "Name: " << name << ", whyMessage: " << whyMessage
+                       << ", waitFor: " << waitFor);
 }
 
 }  // namespace
diff --git a/src/mongo/s/catalog/dist_lock_ping_info.cpp b/src/mongo/s/catalog/dist_lock_ping_info.cpp
index c0643c1fa12..2549e55bb19 100644
--- a/src/mongo/s/catalog/dist_lock_ping_info.cpp
+++ b/src/mongo/s/catalog/dist_lock_ping_info.cpp
@@ -42,4 +42,4 @@ DistLockPingInfo::DistLockPingInfo(
       configLocalTime(remoteArg),
       lockSessionId(std::move(tsArg)),
       electionId(std::move(electionIdArg)) {}
-}
+}  // namespace mongo
diff --git a/src/mongo/s/catalog/dist_lock_ping_info.h b/src/mongo/s/catalog/dist_lock_ping_info.h
index e3db046db20..6e236fb5133 100644
--- a/src/mongo/s/catalog/dist_lock_ping_info.h
+++ b/src/mongo/s/catalog/dist_lock_ping_info.h
@@ -64,4 +64,4 @@ struct DistLockPingInfo {
     // Note: unused by legacy dist lock.
     OID electionId;
 };
-}
+}  // namespace mongo
diff --git a/src/mongo/s/catalog/mongo_version_range.cpp b/src/mongo/s/catalog/mongo_version_range.cpp
index c92fcb0b749..a0c5f505817 100644
--- a/src/mongo/s/catalog/mongo_version_range.cpp
+++ b/src/mongo/s/catalog/mongo_version_range.cpp
@@ -148,4 +148,4 @@ bool isInMongoVersionRanges(StringData version, const vector<MongoVersionRange>&
 
     return false;
 }
-}
+}  // namespace mongo
diff --git a/src/mongo/s/catalog/mongo_version_range.h b/src/mongo/s/catalog/mongo_version_range.h
index 5e8d79807a7..f995864a689 100644
--- a/src/mongo/s/catalog/mongo_version_range.h
+++ b/src/mongo/s/catalog/mongo_version_range.h
@@ -60,4 +60,4 @@ struct MongoVersionRange {
 };
 
 bool isInMongoVersionRanges(StringData version, const std::vector<MongoVersionRange>& ranges);
-}
+}  // namespace mongo
diff --git a/src/mongo/s/catalog/sharding_catalog_client_impl.cpp b/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
index 23db44c5453..2084959330e 100644
--- a/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_client_impl.cpp
@@ -260,14 +260,14 @@ StatusWith<repl::OpTimeWith<std::vector<DatabaseType>>> ShardingCatalogClientImp
     for (const BSONObj& doc : findStatus.getValue().value) {
         auto dbRes = DatabaseType::fromBSON(doc);
         if (!dbRes.isOK()) {
-            return dbRes.getStatus().withContext(stream() << "Failed to parse database document "
-                                                          << doc);
+            return dbRes.getStatus().withContext(stream()
+                                                 << "Failed to parse database document " << doc);
         }
 
         Status validateStatus = dbRes.getValue().validate();
         if (!validateStatus.isOK()) {
-            return validateStatus.withContext(stream() << "Failed to validate database document "
-                                                       << doc);
+            return validateStatus.withContext(stream()
+                                              << "Failed to validate database document " << doc);
         }
 
         databases.push_back(dbRes.getValue());
@@ -377,9 +377,7 @@ StatusWith<std::vector<CollectionType>> ShardingCatalogClientImpl::getCollection
         if (!collectionResult.isOK()) {
             return {ErrorCodes::FailedToParse,
                     str::stream() << "error while parsing " << CollectionType::ConfigNS.ns()
-                                  << " document: "
-                                  << obj
-                                  << " : "
+                                  << " document: " << obj << " : "
                                   << collectionResult.getStatus().toString()};
         }
 
@@ -591,14 +589,14 @@ StatusWith<repl::OpTimeWith<std::vector<ShardType>>> ShardingCatalogClientImpl::
     for (const BSONObj& doc : findStatus.getValue().value) {
         auto shardRes = ShardType::fromBSON(doc);
         if (!shardRes.isOK()) {
-            return shardRes.getStatus().withContext(stream() << "Failed to parse shard document "
-                                                             << doc);
+            return shardRes.getStatus().withContext(stream()
+                                                    << "Failed to parse shard document " << doc);
         }
 
         Status validateStatus = shardRes.getValue().validate();
         if (!validateStatus.isOK()) {
-            return validateStatus.withContext(stream() << "Failed to validate shard document "
-                                                       << doc);
+            return validateStatus.withContext(stream()
+                                              << "Failed to validate shard document " << doc);
         }
 
         shards.push_back(shardRes.getValue());
@@ -714,9 +712,9 @@ Status ShardingCatalogClientImpl::applyChunkOpsDeprecated(OperationContext* opCt
     invariant(serverGlobalParams.clusterRole == ClusterRole::ConfigServer ||
               (readConcern == repl::ReadConcernLevel::kMajorityReadConcern &&
                writeConcern.wMode == WriteConcernOptions::kMajority));
-    BSONObj cmd = BSON("applyOps" << updateOps << "preCondition" << preCondition
-                                  << WriteConcernOptions::kWriteConcernField
-                                  << writeConcern.toBSON());
+    BSONObj cmd =
+        BSON("applyOps" << updateOps << "preCondition" << preCondition
+                        << WriteConcernOptions::kWriteConcernField << writeConcern.toBSON());
 
     auto response =
         Grid::get(opCtx)->shardRegistry()->getConfigShard()->runCommandWithFixedRetryAttempts(
@@ -773,11 +771,11 @@ Status ShardingCatalogClientImpl::applyChunkOpsDeprecated(OperationContext* opCt
         const auto& newestChunk = chunkWithStatus.getValue();
 
         if (newestChunk.empty()) {
-            errMsg = str::stream() << "chunk operation commit failed: version "
-                                   << lastChunkVersion.toString()
-                                   << " doesn't exist in namespace: " << nss.ns()
-                                   << ". Unable to save chunk ops. Command: " << cmd
-                                   << ". Result: " << response.getValue().response;
+            errMsg = str::stream()
+                << "chunk operation commit failed: version " << lastChunkVersion.toString()
+                << " doesn't exist in namespace: " << nss.ns()
+                << ". Unable to save chunk ops. Command: " << cmd
+                << ". Result: " << response.getValue().response;
             return status.withContext(errMsg);
         };
 
diff --git a/src/mongo/s/catalog/sharding_catalog_test.cpp b/src/mongo/s/catalog/sharding_catalog_test.cpp
index ce7790031e3..0885054f185 100644
--- a/src/mongo/s/catalog/sharding_catalog_test.cpp
+++ b/src/mongo/s/catalog/sharding_catalog_test.cpp
@@ -67,8 +67,8 @@ using executor::NetworkInterfaceMock;
 using executor::RemoteCommandRequest;
 using executor::RemoteCommandResponse;
 using executor::TaskExecutor;
-using rpc::ReplSetMetadata;
 using repl::OpTime;
+using rpc::ReplSetMetadata;
 using std::vector;
 using unittest::assertGet;
 
@@ -101,7 +101,6 @@ TEST_F(ShardingCatalogClientTest, GetCollectionExisting) {
 
     onFindWithMetadataCommand(
         [this, &expectedColl, newOpTime](const RemoteCommandRequest& request) {
-
             ASSERT_BSONOBJ_EQ(getReplSecondaryOkMetadata(),
                               rpc::TrackingMetadata::removeTrackingData(request.metadata));
 
@@ -599,10 +598,8 @@ TEST_F(ShardingCatalogClientTest, RunUserManagementWriteCommandSuccess) {
                                << "writeConcern"
                                << BSON("w"
                                        << "majority"
-                                       << "wtimeout"
-                                       << 0)
-                               << "maxTimeMS"
-                               << 30000),
+                                       << "wtimeout" << 0)
+                               << "maxTimeMS" << 30000),
                           request.cmdObj);
 
         ASSERT_BSONOBJ_EQ(BSON(rpc::kReplSetMetadataFieldName << 1),
@@ -622,14 +619,14 @@ TEST_F(ShardingCatalogClientTest, RunUserManagementWriteCommandInvalidWriteConce
     configTargeter()->setFindHostReturnValue(HostAndPort("TestHost1"));
 
     BSONObjBuilder responseBuilder;
-    bool ok = catalogClient()->runUserManagementWriteCommand(operationContext(),
-                                                             "dropUser",
-                                                             "test",
-                                                             BSON("dropUser"
-                                                                  << "test"
-                                                                  << "writeConcern"
-                                                                  << BSON("w" << 2)),
-                                                             &responseBuilder);
+    bool ok =
+        catalogClient()->runUserManagementWriteCommand(operationContext(),
+                                                       "dropUser",
+                                                       "test",
+                                                       BSON("dropUser"
+                                                            << "test"
+                                                            << "writeConcern" << BSON("w" << 2)),
+                                                       &responseBuilder);
     ASSERT_FALSE(ok);
 
     Status commandStatus = getStatusFromCommandResult(responseBuilder.obj());
@@ -648,22 +645,23 @@ TEST_F(ShardingCatalogClientTest, RunUserManagementWriteCommandRewriteWriteConce
         },
         Status::OK());
 
-    auto future = launchAsync([this] {
-        BSONObjBuilder responseBuilder;
-        bool ok = catalogClient()->runUserManagementWriteCommand(operationContext(),
-                                                                 "dropUser",
-                                                                 "test",
-                                                                 BSON("dropUser"
-                                                                      << "test"
-                                                                      << "writeConcern"
-                                                                      << BSON("w" << 1 << "wtimeout"
-                                                                                  << 30)),
-                                                                 &responseBuilder);
-        ASSERT_FALSE(ok);
-
-        Status commandStatus = getStatusFromCommandResult(responseBuilder.obj());
-        ASSERT_EQUALS(ErrorCodes::UserNotFound, commandStatus);
-    });
+    auto future =
+        launchAsync([this] {
+            BSONObjBuilder responseBuilder;
+            bool ok =
+                catalogClient()->runUserManagementWriteCommand(
+                    operationContext(),
+                    "dropUser",
+                    "test",
+                    BSON("dropUser"
+                         << "test"
+                         << "writeConcern" << BSON("w" << 1 << "wtimeout" << 30)),
+                    &responseBuilder);
+            ASSERT_FALSE(ok);
+
+            Status commandStatus = getStatusFromCommandResult(responseBuilder.obj());
+            ASSERT_EQUALS(ErrorCodes::UserNotFound, commandStatus);
+        });
 
     onCommand([](const RemoteCommandRequest& request) {
         ASSERT_EQUALS("test", request.dbname);
@@ -672,10 +670,8 @@ TEST_F(ShardingCatalogClientTest, RunUserManagementWriteCommandRewriteWriteConce
                                << "writeConcern"
                                << BSON("w"
                                        << "majority"
-                                       << "wtimeout"
-                                       << 30)
-                               << "maxTimeMS"
-                               << 30000),
+                                       << "wtimeout" << 30)
+                               << "maxTimeMS" << 30000),
                           request.cmdObj);
 
         ASSERT_BSONOBJ_EQ(BSON(rpc::kReplSetMetadataFieldName << 1),
@@ -763,10 +759,8 @@ TEST_F(ShardingCatalogClientTest, RunUserManagementWriteCommandNotMasterRetrySuc
                                << "writeConcern"
                                << BSON("w"
                                        << "majority"
-                                       << "wtimeout"
-                                       << 0)
-                               << "maxTimeMS"
-                               << 30000),
+                                       << "wtimeout" << 0)
+                               << "maxTimeMS" << 30000),
                           request.cmdObj);
 
         ASSERT_BSONOBJ_EQ(BSON(rpc::kReplSetMetadataFieldName << 1),
@@ -801,7 +795,6 @@ TEST_F(ShardingCatalogClientTest, GetCollectionsValidResultsNoDb) {
     const OpTime newOpTime(Timestamp(7, 6), 5);
 
     auto future = launchAsync([this, newOpTime] {
-
         OpTime opTime;
         const auto& collections =
             assertGet(catalogClient()->getCollections(operationContext(), nullptr, &opTime));
@@ -1202,8 +1195,7 @@ TEST_F(ShardingCatalogClientTest, ApplyChunkOpsDeprecatedSuccessful) {
         ASSERT_EQUALS("config", request.dbname);
         ASSERT_BSONOBJ_EQ(BSON("w"
                                << "majority"
-                               << "wtimeout"
-                               << 60000),
+                               << "wtimeout" << 60000),
                           request.cmdObj["writeConcern"].Obj());
         ASSERT_BSONOBJ_EQ(BSON(rpc::kReplSetMetadataFieldName << 1),
                           rpc::TrackingMetadata::removeTrackingData(request.metadata));
diff --git a/src/mongo/s/catalog/type_changelog_test.cpp b/src/mongo/s/catalog/type_changelog_test.cpp
index b2a2b522299..3142901d06a 100644
--- a/src/mongo/s/catalog/type_changelog_test.cpp
+++ b/src/mongo/s/catalog/type_changelog_test.cpp
@@ -46,12 +46,10 @@ TEST(ChangeLogType, Empty) {
 
 TEST(ChangeLogType, Valid) {
     BSONObj obj = BSON(ChangeLogType::changeId("host.local-2012-11-21T19:14:10-8")
-                       << ChangeLogType::server("host.local")
-                       << ChangeLogType::shard("shardname")
+                       << ChangeLogType::server("host.local") << ChangeLogType::shard("shardname")
                        << ChangeLogType::clientAddr("192.168.0.189:51128")
                        << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1))
-                       << ChangeLogType::what("split")
-                       << ChangeLogType::ns("test.test")
+                       << ChangeLogType::what("split") << ChangeLogType::ns("test.test")
                        << ChangeLogType::details(BSON("dummy"
                                                       << "info")));
 
@@ -77,8 +75,7 @@ TEST(ChangeLogType, MissingChangeId) {
                        << ChangeLogType::shard("shardname")
                        << ChangeLogType::clientAddr("192.168.0.189:51128")
                        << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1))
-                       << ChangeLogType::what("split")
-                       << ChangeLogType::ns("test.test")
+                       << ChangeLogType::what("split") << ChangeLogType::ns("test.test")
                        << ChangeLogType::details(BSON("dummy"
                                                       << "info")));
 
@@ -91,8 +88,7 @@ TEST(ChangeLogType, MissingServer) {
                        << ChangeLogType::shard("shardname")
                        << ChangeLogType::clientAddr("192.168.0.189:51128")
                        << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1))
-                       << ChangeLogType::what("split")
-                       << ChangeLogType::ns("test.test")
+                       << ChangeLogType::what("split") << ChangeLogType::ns("test.test")
                        << ChangeLogType::details(BSON("dummy"
                                                       << "info")));
 
@@ -102,11 +98,9 @@ TEST(ChangeLogType, MissingServer) {
 
 TEST(ChangeLogType, MissingClientAddr) {
     BSONObj obj = BSON(ChangeLogType::changeId("host.local-2012-11-21T19:14:10-8")
-                       << ChangeLogType::server("host.local")
-                       << ChangeLogType::shard("shardname")
+                       << ChangeLogType::server("host.local") << ChangeLogType::shard("shardname")
                        << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1))
-                       << ChangeLogType::what("split")
-                       << ChangeLogType::ns("test.test")
+                       << ChangeLogType::what("split") << ChangeLogType::ns("test.test")
                        << ChangeLogType::details(BSON("dummy"
                                                       << "info")));
 
@@ -116,11 +110,9 @@ TEST(ChangeLogType, MissingClientAddr) {
 
 TEST(ChangeLogType, MissingTime) {
     BSONObj obj = BSON(ChangeLogType::changeId("host.local-2012-11-21T19:14:10-8")
-                       << ChangeLogType::server("host.local")
-                       << ChangeLogType::shard("shardname")
+                       << ChangeLogType::server("host.local") << ChangeLogType::shard("shardname")
                        << ChangeLogType::clientAddr("192.168.0.189:51128")
-                       << ChangeLogType::what("split")
-                       << ChangeLogType::ns("test.test")
+                       << ChangeLogType::what("split") << ChangeLogType::ns("test.test")
                        << ChangeLogType::details(BSON("dummy"
                                                       << "info")));
 
@@ -130,8 +122,7 @@ TEST(ChangeLogType, MissingTime) {
 
 TEST(ChangeLogType, MissingWhat) {
     BSONObj obj = BSON(ChangeLogType::changeId("host.local-2012-11-21T19:14:10-8")
-                       << ChangeLogType::server("host.local")
-                       << ChangeLogType::shard("shardname")
+                       << ChangeLogType::server("host.local") << ChangeLogType::shard("shardname")
                        << ChangeLogType::clientAddr("192.168.0.189:51128")
                        << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1))
                        << ChangeLogType::ns("test.test")
@@ -143,14 +134,13 @@ TEST(ChangeLogType, MissingWhat) {
 }
 
 TEST(ChangeLogType, MissingNS) {
-    BSONObj obj = BSON(ChangeLogType::changeId("host.local-2012-11-21T19:14:10-8")
-                       << ChangeLogType::server("host.local")
-                       << ChangeLogType::shard("shardname")
-                       << ChangeLogType::clientAddr("192.168.0.189:51128")
-                       << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1))
-                       << ChangeLogType::what("split")
-                       << ChangeLogType::details(BSON("dummy"
-                                                      << "info")));
+    BSONObj obj =
+        BSON(ChangeLogType::changeId("host.local-2012-11-21T19:14:10-8")
+             << ChangeLogType::server("host.local") << ChangeLogType::shard("shardname")
+             << ChangeLogType::clientAddr("192.168.0.189:51128")
+             << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1)) << ChangeLogType::what("split")
+             << ChangeLogType::details(BSON("dummy"
+                                            << "info")));
 
     auto changeLogResult = ChangeLogType::fromBSON(obj);
     ASSERT_OK(changeLogResult.getStatus());
@@ -170,12 +160,10 @@ TEST(ChangeLogType, MissingNS) {
 
 TEST(ChangeLogType, MissingDetails) {
     BSONObj obj = BSON(ChangeLogType::changeId("host.local-2012-11-21T19:14:10-8")
-                       << ChangeLogType::server("host.local")
-                       << ChangeLogType::shard("shardname")
+                       << ChangeLogType::server("host.local") << ChangeLogType::shard("shardname")
                        << ChangeLogType::clientAddr("192.168.0.189:51128")
                        << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1))
-                       << ChangeLogType::what("split")
-                       << ChangeLogType::ns("test.test"));
+                       << ChangeLogType::what("split") << ChangeLogType::ns("test.test"));
 
     auto changeLogResult = ChangeLogType::fromBSON(obj);
     ASSERT_EQ(ErrorCodes::NoSuchKey, changeLogResult.getStatus());
@@ -186,8 +174,7 @@ TEST(ChangeLogType, MissingShard) {
                        << ChangeLogType::server("host.local")
                        << ChangeLogType::clientAddr("192.168.0.189:51128")
                        << ChangeLogType::time(Date_t::fromMillisSinceEpoch(1))
-                       << ChangeLogType::what("split")
-                       << ChangeLogType::ns("test.test")
+                       << ChangeLogType::what("split") << ChangeLogType::ns("test.test")
                        << ChangeLogType::details(BSON("dummy"
                                                       << "info")));
 
diff --git a/src/mongo/s/catalog/type_chunk.cpp b/src/mongo/s/catalog/type_chunk.cpp
index c627bd7c824..fbe61500c82 100644
--- a/src/mongo/s/catalog/type_chunk.cpp
+++ b/src/mongo/s/catalog/type_chunk.cpp
@@ -68,8 +68,8 @@ const char kMaxKey[] = "max";
 Status extractObject(const BSONObj& obj, const std::string& fieldName, BSONElement* bsonElement) {
     Status elementStatus = bsonExtractTypedField(obj, fieldName, Object, bsonElement);
     if (!elementStatus.isOK()) {
-        return elementStatus.withContext(str::stream() << "The field '" << fieldName
-                                                       << "' cannot be parsed");
+        return elementStatus.withContext(str::stream()
+                                         << "The field '" << fieldName << "' cannot be parsed");
     }
 
     if (bsonElement->Obj().isEmpty()) {
@@ -108,8 +108,8 @@ StatusWith<ChunkRange> ChunkRange::fromBSON(const BSONObj& obj) {
 
     if (SimpleBSONObjComparator::kInstance.evaluate(minKey.Obj() >= maxKey.Obj())) {
         return {ErrorCodes::FailedToParse,
-                str::stream() << "min: " << minKey.Obj() << " should be less than max: "
-                              << maxKey.Obj()};
+                str::stream() << "min: " << minKey.Obj()
+                              << " should be less than max: " << maxKey.Obj()};
     }
 
     return ChunkRange(minKey.Obj().getOwned(), maxKey.Obj().getOwned());
@@ -135,8 +135,7 @@ const Status ChunkRange::extractKeyPattern(KeyPattern* shardKeyPatternOut) const
             (!min.more() && max.more())) {
             return {ErrorCodes::ShardKeyNotFound,
                     str::stream() << "the shard key of min " << _minKey << " doesn't match with "
-                                  << "the shard key of max "
-                                  << _maxKey};
+                                  << "the shard key of max " << _maxKey};
         }
         b.append(x.fieldName(), 1);
     }
@@ -348,8 +347,8 @@ StatusWith<ChunkType> ChunkType::fromShardBSON(const BSONObj& source, const OID&
 
         if (SimpleBSONObjComparator::kInstance.evaluate(minKey.Obj() >= maxKey.Obj())) {
             return {ErrorCodes::FailedToParse,
-                    str::stream() << "min: " << minKey.Obj() << " should be less than max: "
-                                  << maxKey.Obj()};
+                    str::stream() << "min: " << minKey.Obj()
+                                  << " should be less than max: " << maxKey.Obj()};
         }
 
         chunk._min = minKey.Obj().getOwned();
diff --git a/src/mongo/s/catalog/type_chunk_test.cpp b/src/mongo/s/catalog/type_chunk_test.cpp
index 3e51c306bd5..3c424f815cc 100644
--- a/src/mongo/s/catalog/type_chunk_test.cpp
+++ b/src/mongo/s/catalog/type_chunk_test.cpp
@@ -50,41 +50,32 @@ TEST(ChunkType, MissingConfigRequiredFields) {
     ChunkVersion chunkVersion(1, 2, OID::gen());
 
     BSONObj objModNS =
-        BSON(ChunkType::name(OID::gen().toString()) << ChunkType::min(BSON("a" << 10 << "b" << 10))
-                                                    << ChunkType::max(BSON("a" << 20))
-                                                    << "lastmod"
-                                                    << Timestamp(chunkVersion.toLong())
-                                                    << "lastmodEpoch"
-                                                    << chunkVersion.epoch()
-                                                    << ChunkType::shard("shard0001"));
+        BSON(ChunkType::name(OID::gen().toString())
+             << ChunkType::min(BSON("a" << 10 << "b" << 10)) << ChunkType::max(BSON("a" << 20))
+             << "lastmod" << Timestamp(chunkVersion.toLong()) << "lastmodEpoch"
+             << chunkVersion.epoch() << ChunkType::shard("shard0001"));
     StatusWith<ChunkType> chunkRes = ChunkType::fromConfigBSON(objModNS);
     ASSERT_FALSE(chunkRes.isOK());
 
     BSONObj objModKeys =
-        BSON(ChunkType::name(OID::gen().toString()) << ChunkType::ns("test.mycol") << "lastmod"
-                                                    << Timestamp(chunkVersion.toLong())
-                                                    << "lastmodEpoch"
-                                                    << chunkVersion.epoch()
-                                                    << ChunkType::shard("shard0001"));
+        BSON(ChunkType::name(OID::gen().toString())
+             << ChunkType::ns("test.mycol") << "lastmod" << Timestamp(chunkVersion.toLong())
+             << "lastmodEpoch" << chunkVersion.epoch() << ChunkType::shard("shard0001"));
     chunkRes = ChunkType::fromConfigBSON(objModKeys);
     ASSERT_FALSE(chunkRes.isOK());
 
     BSONObj objModShard =
-        BSON(ChunkType::name(OID::gen().toString()) << ChunkType::ns("test.mycol")
-                                                    << ChunkType::min(BSON("a" << 10 << "b" << 10))
-                                                    << ChunkType::max(BSON("a" << 20))
-                                                    << "lastmod"
-                                                    << Timestamp(chunkVersion.toLong())
-                                                    << "lastmodEpoch"
-                                                    << chunkVersion.epoch());
+        BSON(ChunkType::name(OID::gen().toString())
+             << ChunkType::ns("test.mycol") << ChunkType::min(BSON("a" << 10 << "b" << 10))
+             << ChunkType::max(BSON("a" << 20)) << "lastmod" << Timestamp(chunkVersion.toLong())
+             << "lastmodEpoch" << chunkVersion.epoch());
     chunkRes = ChunkType::fromConfigBSON(objModShard);
     ASSERT_FALSE(chunkRes.isOK());
 
     BSONObj objModVersion =
-        BSON(ChunkType::name(OID::gen().toString()) << ChunkType::ns("test.mycol")
-                                                    << ChunkType::min(BSON("a" << 10 << "b" << 10))
-                                                    << ChunkType::max(BSON("a" << 20))
-                                                    << ChunkType::shard("shard0001"));
+        BSON(ChunkType::name(OID::gen().toString())
+             << ChunkType::ns("test.mycol") << ChunkType::min(BSON("a" << 10 << "b" << 10))
+             << ChunkType::max(BSON("a" << 20)) << ChunkType::shard("shard0001"));
     chunkRes = ChunkType::fromConfigBSON(objModVersion);
     ASSERT_FALSE(chunkRes.isOK());
 }
@@ -100,8 +91,8 @@ TEST(ChunkType, MissingShardRequiredFields) {
     ASSERT_EQUALS(chunkRes.getStatus(), ErrorCodes::NoSuchKey);
     ASSERT_STRING_CONTAINS(chunkRes.getStatus().reason(), ChunkType::minShardID.name());
 
-    BSONObj objModMax = BSON(
-        ChunkType::minShardID(kMin) << ChunkType::shard(kShard.toString()) << "lastmod" << lastmod);
+    BSONObj objModMax = BSON(ChunkType::minShardID(kMin)
+                             << ChunkType::shard(kShard.toString()) << "lastmod" << lastmod);
     chunkRes = ChunkType::fromShardBSON(objModMax, epoch);
     ASSERT_EQUALS(chunkRes.getStatus(), ErrorCodes::NoSuchKey);
     ASSERT_STRING_CONTAINS(chunkRes.getStatus().reason(), ChunkType::max.name());
@@ -112,8 +103,8 @@ TEST(ChunkType, MissingShardRequiredFields) {
     ASSERT_EQUALS(chunkRes.getStatus(), ErrorCodes::NoSuchKey);
     ASSERT_STRING_CONTAINS(chunkRes.getStatus().reason(), ChunkType::shard.name());
 
-    BSONObj objModLastmod = BSON(
-        ChunkType::minShardID(kMin) << ChunkType::max(kMax) << ChunkType::shard(kShard.toString()));
+    BSONObj objModLastmod = BSON(ChunkType::minShardID(kMin)
+                                 << ChunkType::max(kMax) << ChunkType::shard(kShard.toString()));
     chunkRes = ChunkType::fromShardBSON(objModLastmod, epoch);
     ASSERT_EQUALS(chunkRes.getStatus(), ErrorCodes::NoSuchKey);
 }
@@ -123,10 +114,9 @@ TEST(ChunkType, ToFromShardBSON) {
     ChunkVersion chunkVersion(1, 2, epoch);
     auto lastmod = Timestamp(chunkVersion.toLong());
 
-    BSONObj obj = BSON(ChunkType::minShardID(kMin) << ChunkType::max(kMax)
-                                                   << ChunkType::shard(kShard.toString())
-                                                   << "lastmod"
-                                                   << lastmod);
+    BSONObj obj = BSON(ChunkType::minShardID(kMin)
+                       << ChunkType::max(kMax) << ChunkType::shard(kShard.toString()) << "lastmod"
+                       << lastmod);
     ChunkType shardChunk = assertGet(ChunkType::fromShardBSON(obj, epoch));
 
     ASSERT_BSONOBJ_EQ(obj, shardChunk.toShardBSON());
@@ -140,14 +130,10 @@ TEST(ChunkType, ToFromShardBSON) {
 TEST(ChunkType, MinAndMaxShardKeysDifferInNumberOfKeys) {
     ChunkVersion chunkVersion(1, 2, OID::gen());
     BSONObj obj =
-        BSON(ChunkType::name(OID::gen().toString()) << ChunkType::ns("test.mycol")
-                                                    << ChunkType::min(BSON("a" << 10 << "b" << 10))
-                                                    << ChunkType::max(BSON("a" << 20))
-                                                    << "lastmod"
-                                                    << Timestamp(chunkVersion.toLong())
-                                                    << "lastmodEpoch"
-                                                    << chunkVersion.epoch()
-                                                    << ChunkType::shard("shard0001"));
+        BSON(ChunkType::name(OID::gen().toString())
+             << ChunkType::ns("test.mycol") << ChunkType::min(BSON("a" << 10 << "b" << 10))
+             << ChunkType::max(BSON("a" << 20)) << "lastmod" << Timestamp(chunkVersion.toLong())
+             << "lastmodEpoch" << chunkVersion.epoch() << ChunkType::shard("shard0001"));
     StatusWith<ChunkType> chunkRes = ChunkType::fromConfigBSON(obj);
     ASSERT_OK(chunkRes.getStatus());
     ASSERT_FALSE(chunkRes.getValue().validate().isOK());
@@ -155,14 +141,11 @@ TEST(ChunkType, MinAndMaxShardKeysDifferInNumberOfKeys) {
 
 TEST(ChunkType, MinAndMaxShardKeysDifferInKeyNames) {
     ChunkVersion chunkVersion(1, 2, OID::gen());
-    BSONObj obj = BSON(ChunkType::name(OID::gen().toString()) << ChunkType::ns("test.mycol")
-                                                              << ChunkType::min(BSON("a" << 10))
-                                                              << ChunkType::max(BSON("b" << 20))
-                                                              << "lastmod"
-                                                              << Timestamp(chunkVersion.toLong())
-                                                              << "lastmodEpoch"
-                                                              << chunkVersion.epoch()
-                                                              << ChunkType::shard("shard0001"));
+    BSONObj obj =
+        BSON(ChunkType::name(OID::gen().toString())
+             << ChunkType::ns("test.mycol") << ChunkType::min(BSON("a" << 10))
+             << ChunkType::max(BSON("b" << 20)) << "lastmod" << Timestamp(chunkVersion.toLong())
+             << "lastmodEpoch" << chunkVersion.epoch() << ChunkType::shard("shard0001"));
     StatusWith<ChunkType> chunkRes = ChunkType::fromConfigBSON(obj);
     ASSERT_OK(chunkRes.getStatus());
     ASSERT_FALSE(chunkRes.getValue().validate().isOK());
@@ -170,14 +153,11 @@ TEST(ChunkType, MinAndMaxShardKeysDifferInKeyNames) {
 
 TEST(ChunkType, MinToMaxNotAscending) {
     ChunkVersion chunkVersion(1, 2, OID::gen());
-    BSONObj obj = BSON(ChunkType::name(OID::gen().toString()) << ChunkType::ns("test.mycol")
-                                                              << ChunkType::min(BSON("a" << 20))
-                                                              << ChunkType::max(BSON("a" << 10))
-                                                              << "lastmod"
-                                                              << Timestamp(chunkVersion.toLong())
-                                                              << "lastmodEpoch"
-                                                              << chunkVersion.epoch()
-                                                              << ChunkType::shard("shard0001"));
+    BSONObj obj =
+        BSON(ChunkType::name(OID::gen().toString())
+             << ChunkType::ns("test.mycol") << ChunkType::min(BSON("a" << 20))
+             << ChunkType::max(BSON("a" << 10)) << "lastmod" << Timestamp(chunkVersion.toLong())
+             << "lastmodEpoch" << chunkVersion.epoch() << ChunkType::shard("shard0001"));
     StatusWith<ChunkType> chunkRes = ChunkType::fromConfigBSON(obj);
     ASSERT_EQ(ErrorCodes::FailedToParse, chunkRes.getStatus());
 }
@@ -185,14 +165,11 @@ TEST(ChunkType, MinToMaxNotAscending) {
 TEST(ChunkType, ToFromConfigBSON) {
     const std::string chunkID = OID::gen().toString();
     ChunkVersion chunkVersion(1, 2, OID::gen());
-    BSONObj obj = BSON(ChunkType::name(chunkID) << ChunkType::ns("test.mycol")
-                                                << ChunkType::min(BSON("a" << 10))
-                                                << ChunkType::max(BSON("a" << 20))
-                                                << ChunkType::shard("shard0001")
-                                                << "lastmod"
-                                                << Timestamp(chunkVersion.toLong())
-                                                << "lastmodEpoch"
-                                                << chunkVersion.epoch());
+    BSONObj obj =
+        BSON(ChunkType::name(chunkID)
+             << ChunkType::ns("test.mycol") << ChunkType::min(BSON("a" << 10))
+             << ChunkType::max(BSON("a" << 20)) << ChunkType::shard("shard0001") << "lastmod"
+             << Timestamp(chunkVersion.toLong()) << "lastmodEpoch" << chunkVersion.epoch());
     StatusWith<ChunkType> chunkRes = ChunkType::fromConfigBSON(obj);
     ASSERT_OK(chunkRes.getStatus());
     ChunkType chunk = chunkRes.getValue();
diff --git a/src/mongo/s/catalog/type_collection_test.cpp b/src/mongo/s/catalog/type_collection_test.cpp
index 68c1e73b096..9130562aaac 100644
--- a/src/mongo/s/catalog/type_collection_test.cpp
+++ b/src/mongo/s/catalog/type_collection_test.cpp
@@ -48,14 +48,13 @@ TEST(CollectionType, Empty) {
 
 TEST(CollectionType, Basic) {
     const OID oid = OID::gen();
-    StatusWith<CollectionType> status =
-        CollectionType::fromBSON(BSON(CollectionType::fullNs("db.coll")
-                                      << CollectionType::epoch(oid)
-                                      << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
-                                      << CollectionType::keyPattern(BSON("a" << 1))
-                                      << CollectionType::defaultCollation(BSON("locale"
-                                                                               << "fr_CA"))
-                                      << CollectionType::unique(true)));
+    StatusWith<CollectionType> status = CollectionType::fromBSON(BSON(
+        CollectionType::fullNs("db.coll")
+        << CollectionType::epoch(oid) << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
+        << CollectionType::keyPattern(BSON("a" << 1))
+        << CollectionType::defaultCollation(BSON("locale"
+                                                 << "fr_CA"))
+        << CollectionType::unique(true)));
     ASSERT_TRUE(status.isOK());
 
     CollectionType coll = status.getValue();
@@ -76,18 +75,14 @@ TEST(CollectionType, Basic) {
 TEST(CollectionType, AllFieldsPresent) {
     const OID oid = OID::gen();
     const auto uuid = UUID::gen();
-    StatusWith<CollectionType> status =
-        CollectionType::fromBSON(BSON(CollectionType::fullNs("db.coll")
-                                      << CollectionType::epoch(oid)
-                                      << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
-                                      << CollectionType::keyPattern(BSON("a" << 1))
-                                      << CollectionType::defaultCollation(BSON("locale"
-                                                                               << "fr_CA"))
-                                      << CollectionType::unique(true)
-                                      << CollectionType::uuid()
-                                      << uuid
-                                      << "isAssignedShardKey"
-                                      << false));
+    StatusWith<CollectionType> status = CollectionType::fromBSON(BSON(
+        CollectionType::fullNs("db.coll")
+        << CollectionType::epoch(oid) << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
+        << CollectionType::keyPattern(BSON("a" << 1))
+        << CollectionType::defaultCollation(BSON("locale"
+                                                 << "fr_CA"))
+        << CollectionType::unique(true) << CollectionType::uuid() << uuid << "isAssignedShardKey"
+        << false));
     ASSERT_TRUE(status.isOK());
 
     CollectionType coll = status.getValue();
@@ -109,24 +104,20 @@ TEST(CollectionType, AllFieldsPresent) {
 
 TEST(CollectionType, EmptyDefaultCollationFailsToParse) {
     const OID oid = OID::gen();
-    StatusWith<CollectionType> status =
-        CollectionType::fromBSON(BSON(CollectionType::fullNs("db.coll")
-                                      << CollectionType::epoch(oid)
-                                      << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
-                                      << CollectionType::keyPattern(BSON("a" << 1))
-                                      << CollectionType::defaultCollation(BSONObj())
-                                      << CollectionType::unique(true)));
+    StatusWith<CollectionType> status = CollectionType::fromBSON(BSON(
+        CollectionType::fullNs("db.coll")
+        << CollectionType::epoch(oid) << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
+        << CollectionType::keyPattern(BSON("a" << 1)) << CollectionType::defaultCollation(BSONObj())
+        << CollectionType::unique(true)));
     ASSERT_FALSE(status.isOK());
 }
 
 TEST(CollectionType, MissingDefaultCollationParses) {
     const OID oid = OID::gen();
-    StatusWith<CollectionType> status =
-        CollectionType::fromBSON(BSON(CollectionType::fullNs("db.coll")
-                                      << CollectionType::epoch(oid)
-                                      << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
-                                      << CollectionType::keyPattern(BSON("a" << 1))
-                                      << CollectionType::unique(true)));
+    StatusWith<CollectionType> status = CollectionType::fromBSON(BSON(
+        CollectionType::fullNs("db.coll")
+        << CollectionType::epoch(oid) << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
+        << CollectionType::keyPattern(BSON("a" << 1)) << CollectionType::unique(true)));
     ASSERT_TRUE(status.isOK());
 
     CollectionType coll = status.getValue();
@@ -136,14 +127,13 @@ TEST(CollectionType, MissingDefaultCollationParses) {
 
 TEST(CollectionType, DefaultCollationSerializesCorrectly) {
     const OID oid = OID::gen();
-    StatusWith<CollectionType> status =
-        CollectionType::fromBSON(BSON(CollectionType::fullNs("db.coll")
-                                      << CollectionType::epoch(oid)
-                                      << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
-                                      << CollectionType::keyPattern(BSON("a" << 1))
-                                      << CollectionType::defaultCollation(BSON("locale"
-                                                                               << "fr_CA"))
-                                      << CollectionType::unique(true)));
+    StatusWith<CollectionType> status = CollectionType::fromBSON(BSON(
+        CollectionType::fullNs("db.coll")
+        << CollectionType::epoch(oid) << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
+        << CollectionType::keyPattern(BSON("a" << 1))
+        << CollectionType::defaultCollation(BSON("locale"
+                                                 << "fr_CA"))
+        << CollectionType::unique(true)));
     ASSERT_TRUE(status.isOK());
 
     CollectionType coll = status.getValue();
@@ -156,12 +146,10 @@ TEST(CollectionType, DefaultCollationSerializesCorrectly) {
 
 TEST(CollectionType, MissingDefaultCollationIsNotSerialized) {
     const OID oid = OID::gen();
-    StatusWith<CollectionType> status =
-        CollectionType::fromBSON(BSON(CollectionType::fullNs("db.coll")
-                                      << CollectionType::epoch(oid)
-                                      << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
-                                      << CollectionType::keyPattern(BSON("a" << 1))
-                                      << CollectionType::unique(true)));
+    StatusWith<CollectionType> status = CollectionType::fromBSON(BSON(
+        CollectionType::fullNs("db.coll")
+        << CollectionType::epoch(oid) << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
+        << CollectionType::keyPattern(BSON("a" << 1)) << CollectionType::unique(true)));
     ASSERT_TRUE(status.isOK());
 
     CollectionType coll = status.getValue();
@@ -194,16 +182,11 @@ TEST(CollectionType, EpochCorrectness) {
 }
 
 TEST(CollectionType, Pre22Format) {
-    CollectionType coll = assertGet(CollectionType::fromBSON(BSON("_id"
-                                                                  << "db.coll"
-                                                                  << "lastmod"
-                                                                  << Date_t::fromMillisSinceEpoch(1)
-                                                                  << "dropped"
-                                                                  << false
-                                                                  << "key"
-                                                                  << BSON("a" << 1)
-                                                                  << "unique"
-                                                                  << false)));
+    CollectionType coll = assertGet(
+        CollectionType::fromBSON(BSON("_id"
+                                      << "db.coll"
+                                      << "lastmod" << Date_t::fromMillisSinceEpoch(1) << "dropped"
+                                      << false << "key" << BSON("a" << 1) << "unique" << false)));
 
     ASSERT(coll.getNs() == NamespaceString{"db.coll"});
     ASSERT(!coll.getEpoch().isSet());
@@ -216,12 +199,10 @@ TEST(CollectionType, Pre22Format) {
 
 TEST(CollectionType, InvalidCollectionNamespace) {
     const OID oid = OID::gen();
-    StatusWith<CollectionType> result =
-        CollectionType::fromBSON(BSON(CollectionType::fullNs("foo\\bar.coll")
-                                      << CollectionType::epoch(oid)
-                                      << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
-                                      << CollectionType::keyPattern(BSON("a" << 1))
-                                      << CollectionType::unique(true)));
+    StatusWith<CollectionType> result = CollectionType::fromBSON(BSON(
+        CollectionType::fullNs("foo\\bar.coll")
+        << CollectionType::epoch(oid) << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
+        << CollectionType::keyPattern(BSON("a" << 1)) << CollectionType::unique(true)));
     ASSERT_TRUE(result.isOK());
     CollectionType collType = result.getValue();
     ASSERT_FALSE(collType.validate().isOK());
@@ -230,10 +211,10 @@ TEST(CollectionType, InvalidCollectionNamespace) {
 TEST(CollectionType, BadType) {
     const OID oid = OID::gen();
     StatusWith<CollectionType> status = CollectionType::fromBSON(
-        BSON(CollectionType::fullNs() << 1 << CollectionType::epoch(oid)
-                                      << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
-                                      << CollectionType::keyPattern(BSON("a" << 1))
-                                      << CollectionType::unique(true)));
+        BSON(CollectionType::fullNs()
+             << 1 << CollectionType::epoch(oid)
+             << CollectionType::updatedAt(Date_t::fromMillisSinceEpoch(1))
+             << CollectionType::keyPattern(BSON("a" << 1)) << CollectionType::unique(true)));
 
     ASSERT_FALSE(status.isOK());
 }
diff --git a/src/mongo/s/catalog/type_config_version_test.cpp b/src/mongo/s/catalog/type_config_version_test.cpp
index df3a9486f64..6bc2d7eaac2 100644
--- a/src/mongo/s/catalog/type_config_version_test.cpp
+++ b/src/mongo/s/catalog/type_config_version_test.cpp
@@ -254,10 +254,10 @@ TEST(Excludes, BadRangeArray) {
                       << "1.2.3");  // empty bound
     BSONArray includeArr = bab.arr();
 
-    auto versionInfoResult = VersionType::fromBSON(BSON(
-        VersionType::minCompatibleVersion(3) << VersionType::currentVersion(4)
-                                             << VersionType::clusterId(OID::gen())
-                                             << VersionType::excludingMongoVersions(includeArr)));
+    auto versionInfoResult = VersionType::fromBSON(
+        BSON(VersionType::minCompatibleVersion(3)
+             << VersionType::currentVersion(4) << VersionType::clusterId(OID::gen())
+             << VersionType::excludingMongoVersions(includeArr)));
     ASSERT_EQ(ErrorCodes::FailedToParse, versionInfoResult.getStatus());
 }
 
diff --git a/src/mongo/s/catalog/type_database.cpp b/src/mongo/s/catalog/type_database.cpp
index 5dbeb34ab7d..2caf60f308f 100644
--- a/src/mongo/s/catalog/type_database.cpp
+++ b/src/mongo/s/catalog/type_database.cpp
@@ -83,10 +83,10 @@ StatusWith<DatabaseType> DatabaseType::fromBSON(const BSONObj& source) {
         BSONObj versionField = source.getObjectField("version");
         if (versionField.isEmpty()) {
             return Status{ErrorCodes::InternalError,
-                          str::stream() << "DatabaseVersion doesn't exist in database entry "
-                                        << source
-                                        << " despite the config server being in binary version 4.2 "
-                                           "or later."};
+                          str::stream()
+                              << "DatabaseVersion doesn't exist in database entry " << source
+                              << " despite the config server being in binary version 4.2 "
+                                 "or later."};
         }
         dbtVersion = DatabaseVersion::parse(IDLParserErrorContext("DatabaseType"), versionField);
     }
diff --git a/src/mongo/s/catalog/type_database_test.cpp b/src/mongo/s/catalog/type_database_test.cpp
index e4e4b046232..8a9eb73dcda 100644
--- a/src/mongo/s/catalog/type_database_test.cpp
+++ b/src/mongo/s/catalog/type_database_test.cpp
@@ -49,8 +49,7 @@ TEST(DatabaseType, Basic) {
     UUID uuid = UUID::gen();
     StatusWith<DatabaseType> status = DatabaseType::fromBSON(
         BSON(DatabaseType::name("mydb")
-             << DatabaseType::primary("shard")
-             << DatabaseType::sharded(true)
+             << DatabaseType::primary("shard") << DatabaseType::sharded(true)
              << DatabaseType::version(BSON("uuid" << uuid << "lastMod" << 0))));
     ASSERT_TRUE(status.isOK());
 
diff --git a/src/mongo/s/catalog/type_locks_test.cpp b/src/mongo/s/catalog/type_locks_test.cpp
index b00ffe06c0e..b249bb648a9 100644
--- a/src/mongo/s/catalog/type_locks_test.cpp
+++ b/src/mongo/s/catalog/type_locks_test.cpp
@@ -46,12 +46,12 @@ TEST(Validity, Empty) {
 
 TEST(Validity, UnlockedWithOptional) {
     OID testLockID = OID::gen();
-    BSONObj obj = BSON(LocksType::name("dummy")
-                       << LocksType::process("host.local:27017:1352918870:16807")
-                       << LocksType::state(LocksType::State::UNLOCKED)
-                       << LocksType::lockID(testLockID)
-                       << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
-                       << LocksType::why("twiddling thumbs"));
+    BSONObj obj =
+        BSON(LocksType::name("dummy")
+             << LocksType::process("host.local:27017:1352918870:16807")
+             << LocksType::state(LocksType::State::UNLOCKED) << LocksType::lockID(testLockID)
+             << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
+             << LocksType::why("twiddling thumbs"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
@@ -78,12 +78,12 @@ TEST(Validity, UnlockedWithoutOptional) {
 
 TEST(Validity, LockedValid) {
     OID testLockID = OID::gen();
-    BSONObj obj = BSON(LocksType::name("dummy")
-                       << LocksType::process("host.local:27017:1352918870:16807")
-                       << LocksType::state(LocksType::State::LOCKED)
-                       << LocksType::lockID(testLockID)
-                       << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
-                       << LocksType::why("doing balance round"));
+    BSONObj obj =
+        BSON(LocksType::name("dummy")
+             << LocksType::process("host.local:27017:1352918870:16807")
+             << LocksType::state(LocksType::State::LOCKED) << LocksType::lockID(testLockID)
+             << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
+             << LocksType::why("doing balance round"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
@@ -98,11 +98,11 @@ TEST(Validity, LockedValid) {
 }
 
 TEST(Validity, LockedMissingProcess) {
-    BSONObj obj = BSON(LocksType::name("dummy")
-                       << LocksType::state(LocksType::State::LOCKED)
-                       << LocksType::lockID(OID::gen())
-                       << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
-                       << LocksType::why("doing balance round"));
+    BSONObj obj =
+        BSON(LocksType::name("dummy")
+             << LocksType::state(LocksType::State::LOCKED) << LocksType::lockID(OID::gen())
+             << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
+             << LocksType::why("doing balance round"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
@@ -124,11 +124,10 @@ TEST(Validity, LockedMissingLockID) {
 }
 
 TEST(Validity, LockedMissingWho) {
-    BSONObj obj =
-        BSON(LocksType::name("dummy") << LocksType::process("host.local:27017:1352918870:16807")
-                                      << LocksType::state(LocksType::State::LOCKED)
-                                      << LocksType::lockID(OID::gen())
-                                      << LocksType::why("twiddling thumbs"));
+    BSONObj obj = BSON(LocksType::name("dummy")
+                       << LocksType::process("host.local:27017:1352918870:16807")
+                       << LocksType::state(LocksType::State::LOCKED)
+                       << LocksType::lockID(OID::gen()) << LocksType::why("twiddling thumbs"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
@@ -137,11 +136,11 @@ TEST(Validity, LockedMissingWho) {
 }
 
 TEST(Validity, LockedMissingWhy) {
-    BSONObj obj = BSON(LocksType::name("dummy")
-                       << LocksType::process("host.local:27017:1352918870:16807")
-                       << LocksType::state(LocksType::State::LOCKED)
-                       << LocksType::lockID(OID::gen())
-                       << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249"));
+    BSONObj obj =
+        BSON(LocksType::name("dummy")
+             << LocksType::process("host.local:27017:1352918870:16807")
+             << LocksType::state(LocksType::State::LOCKED) << LocksType::lockID(OID::gen())
+             << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
@@ -150,12 +149,12 @@ TEST(Validity, LockedMissingWhy) {
 }
 
 TEST(Validity, ContestedValid) {
-    BSONObj obj = BSON(LocksType::name("dummy")
-                       << LocksType::process("host.local:27017:1352918870:16807")
-                       << LocksType::state(LocksType::State::LOCK_PREP)
-                       << LocksType::lockID(OID::gen())
-                       << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
-                       << LocksType::why("twiddling thumbs"));
+    BSONObj obj =
+        BSON(LocksType::name("dummy")
+             << LocksType::process("host.local:27017:1352918870:16807")
+             << LocksType::state(LocksType::State::LOCK_PREP) << LocksType::lockID(OID::gen())
+             << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
+             << LocksType::why("twiddling thumbs"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
@@ -164,11 +163,11 @@ TEST(Validity, ContestedValid) {
 }
 
 TEST(Validity, ContestedMissingProcess) {
-    BSONObj obj = BSON(LocksType::name("dummy")
-                       << LocksType::state(LocksType::State::LOCK_PREP)
-                       << LocksType::lockID(OID::gen())
-                       << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
-                       << LocksType::why("twiddling thumbs"));
+    BSONObj obj =
+        BSON(LocksType::name("dummy")
+             << LocksType::state(LocksType::State::LOCK_PREP) << LocksType::lockID(OID::gen())
+             << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249")
+             << LocksType::why("twiddling thumbs"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
@@ -190,11 +189,10 @@ TEST(Validity, ContestedMissingLockID) {
 }
 
 TEST(Validity, ContestedMissingWho) {
-    BSONObj obj =
-        BSON(LocksType::name("dummy") << LocksType::process("host.local:27017:1352918870:16807")
-                                      << LocksType::state(LocksType::State::LOCK_PREP)
-                                      << LocksType::lockID(OID::gen())
-                                      << LocksType::why("doing balance round"));
+    BSONObj obj = BSON(LocksType::name("dummy")
+                       << LocksType::process("host.local:27017:1352918870:16807")
+                       << LocksType::state(LocksType::State::LOCK_PREP)
+                       << LocksType::lockID(OID::gen()) << LocksType::why("doing balance round"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
@@ -203,11 +201,11 @@ TEST(Validity, ContestedMissingWho) {
 }
 
 TEST(Validity, ContestedMissingWhy) {
-    BSONObj obj = BSON(LocksType::name("dummy")
-                       << LocksType::process("host.local:27017:1352918870:16807")
-                       << LocksType::state(LocksType::State::LOCK_PREP)
-                       << LocksType::lockID(OID::gen())
-                       << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249"));
+    BSONObj obj =
+        BSON(LocksType::name("dummy")
+             << LocksType::process("host.local:27017:1352918870:16807")
+             << LocksType::state(LocksType::State::LOCK_PREP) << LocksType::lockID(OID::gen())
+             << LocksType::who("host.local:27017:1352918870:16807:Dummy:282475249"));
     auto locksResult = LocksType::fromBSON(obj);
     ASSERT_OK(locksResult.getStatus());
 
diff --git a/src/mongo/s/catalog/type_mongos_test.cpp b/src/mongo/s/catalog/type_mongos_test.cpp
index a253ed68d00..7007305f412 100644
--- a/src/mongo/s/catalog/type_mongos_test.cpp
+++ b/src/mongo/s/catalog/type_mongos_test.cpp
@@ -41,10 +41,8 @@ using namespace mongo;
 
 TEST(Validity, MissingName) {
     BSONObj obj = BSON(MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::uptime(100)
-                       << MongosType::waiting(false)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::configVersion(0)
+                       << MongosType::uptime(100) << MongosType::waiting(false)
+                       << MongosType::mongoVersion("x.x.x") << MongosType::configVersion(0)
                        << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
@@ -53,10 +51,8 @@ TEST(Validity, MissingName) {
 
 TEST(Validity, MissingPing) {
     BSONObj obj = BSON(MongosType::name("localhost:27017")
-                       << MongosType::uptime(100)
-                       << MongosType::waiting(false)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::configVersion(0)
+                       << MongosType::uptime(100) << MongosType::waiting(false)
+                       << MongosType::mongoVersion("x.x.x") << MongosType::configVersion(0)
                        << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
@@ -64,36 +60,33 @@ TEST(Validity, MissingPing) {
 }
 
 TEST(Validity, MissingUp) {
-    BSONObj obj = BSON(MongosType::name("localhost:27017")
-                       << MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::waiting(false)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::configVersion(0)
-                       << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
+    BSONObj obj =
+        BSON(MongosType::name("localhost:27017")
+             << MongosType::ping(Date_t::fromMillisSinceEpoch(1)) << MongosType::waiting(false)
+             << MongosType::mongoVersion("x.x.x") << MongosType::configVersion(0)
+             << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
     ASSERT_EQ(ErrorCodes::NoSuchKey, mongosTypeResult.getStatus());
 }
 
 TEST(Validity, MissingWaiting) {
-    BSONObj obj = BSON(MongosType::name("localhost:27017")
-                       << MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::uptime(100)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::configVersion(0)
-                       << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
+    BSONObj obj =
+        BSON(MongosType::name("localhost:27017")
+             << MongosType::ping(Date_t::fromMillisSinceEpoch(1)) << MongosType::uptime(100)
+             << MongosType::mongoVersion("x.x.x") << MongosType::configVersion(0)
+             << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
     ASSERT_EQ(ErrorCodes::NoSuchKey, mongosTypeResult.getStatus());
 }
 
 TEST(Validity, MissingMongoVersion) {
-    BSONObj obj = BSON(MongosType::name("localhost:27017")
-                       << MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::uptime(100)
-                       << MongosType::waiting(false)
-                       << MongosType::configVersion(0)
-                       << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
+    BSONObj obj =
+        BSON(MongosType::name("localhost:27017")
+             << MongosType::ping(Date_t::fromMillisSinceEpoch(1)) << MongosType::uptime(100)
+             << MongosType::waiting(false) << MongosType::configVersion(0)
+             << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
     ASSERT_OK(mongosTypeResult.getStatus());
@@ -107,12 +100,11 @@ TEST(Validity, MissingMongoVersion) {
 }
 
 TEST(Validity, MissingConfigVersion) {
-    BSONObj obj = BSON(MongosType::name("localhost:27017")
-                       << MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::uptime(100)
-                       << MongosType::waiting(false)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
+    BSONObj obj =
+        BSON(MongosType::name("localhost:27017")
+             << MongosType::ping(Date_t::fromMillisSinceEpoch(1)) << MongosType::uptime(100)
+             << MongosType::waiting(false) << MongosType::mongoVersion("x.x.x")
+             << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
     ASSERT_OK(mongosTypeResult.getStatus());
@@ -128,10 +120,8 @@ TEST(Validity, MissingConfigVersion) {
 TEST(Validity, MissingAdvisoryHostFQDNs) {
     BSONObj obj = BSON(MongosType::name("localhost:27017")
                        << MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::uptime(100)
-                       << MongosType::waiting(false)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::configVersion(0));
+                       << MongosType::uptime(100) << MongosType::waiting(false)
+                       << MongosType::mongoVersion("x.x.x") << MongosType::configVersion(0));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
     ASSERT_OK(mongosTypeResult.getStatus());
@@ -144,10 +134,8 @@ TEST(Validity, MissingAdvisoryHostFQDNs) {
 TEST(Validity, EmptyAdvisoryHostFQDNs) {
     BSONObj obj = BSON(MongosType::name("localhost:27017")
                        << MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::uptime(100)
-                       << MongosType::waiting(false)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::configVersion(0)
+                       << MongosType::uptime(100) << MongosType::waiting(false)
+                       << MongosType::mongoVersion("x.x.x") << MongosType::configVersion(0)
                        << MongosType::advisoryHostFQDNs(BSONArrayBuilder().arr()));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
@@ -162,10 +150,8 @@ TEST(Validity, EmptyAdvisoryHostFQDNs) {
 TEST(Validity, BadTypeAdvisoryHostFQDNs) {
     BSONObj obj = BSON(MongosType::name("localhost:27017")
                        << MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::uptime(100)
-                       << MongosType::waiting(false)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::configVersion(0)
+                       << MongosType::uptime(100) << MongosType::waiting(false)
+                       << MongosType::mongoVersion("x.x.x") << MongosType::configVersion(0)
                        << MongosType::advisoryHostFQDNs(BSON_ARRAY("foo" << 0 << "baz")));
 
     auto mongosTypeResult = MongosType::fromBSON(obj);
@@ -175,10 +161,8 @@ TEST(Validity, BadTypeAdvisoryHostFQDNs) {
 TEST(Validity, Valid) {
     BSONObj obj = BSON(MongosType::name("localhost:27017")
                        << MongosType::ping(Date_t::fromMillisSinceEpoch(1))
-                       << MongosType::uptime(100)
-                       << MongosType::waiting(false)
-                       << MongosType::mongoVersion("x.x.x")
-                       << MongosType::configVersion(0)
+                       << MongosType::uptime(100) << MongosType::waiting(false)
+                       << MongosType::mongoVersion("x.x.x") << MongosType::configVersion(0)
                        << MongosType::advisoryHostFQDNs(BSON_ARRAY("foo"
                                                                    << "bar"
                                                                    << "baz")));
diff --git a/src/mongo/s/catalog/type_shard_collection.h b/src/mongo/s/catalog/type_shard_collection.h
index 95ec62e7775..af96e3d7785 100644
--- a/src/mongo/s/catalog/type_shard_collection.h
+++ b/src/mongo/s/catalog/type_shard_collection.h
@@ -47,24 +47,24 @@ public:
     using ShardCollectionTypeBase::kUuidFieldName;
 
     // Make getters and setters accessible.
+    using ShardCollectionTypeBase::getDefaultCollation;
+    using ShardCollectionTypeBase::getEnterCriticalSectionCounter;
+    using ShardCollectionTypeBase::getEpoch;
+    using ShardCollectionTypeBase::getKeyPattern;
+    using ShardCollectionTypeBase::getLastRefreshedCollectionVersion;
     using ShardCollectionTypeBase::getNss;
-    using ShardCollectionTypeBase::setNss;
+    using ShardCollectionTypeBase::getRefreshing;
+    using ShardCollectionTypeBase::getUnique;
     using ShardCollectionTypeBase::getUuid;
-    using ShardCollectionTypeBase::setUuid;
-    using ShardCollectionTypeBase::getEpoch;
+    using ShardCollectionTypeBase::setDefaultCollation;
+    using ShardCollectionTypeBase::setEnterCriticalSectionCounter;
     using ShardCollectionTypeBase::setEpoch;
-    using ShardCollectionTypeBase::getKeyPattern;
     using ShardCollectionTypeBase::setKeyPattern;
-    using ShardCollectionTypeBase::getDefaultCollation;
-    using ShardCollectionTypeBase::setDefaultCollation;
-    using ShardCollectionTypeBase::getUnique;
-    using ShardCollectionTypeBase::setUnique;
-    using ShardCollectionTypeBase::getRefreshing;
-    using ShardCollectionTypeBase::setRefreshing;
-    using ShardCollectionTypeBase::getLastRefreshedCollectionVersion;
     using ShardCollectionTypeBase::setLastRefreshedCollectionVersion;
-    using ShardCollectionTypeBase::getEnterCriticalSectionCounter;
-    using ShardCollectionTypeBase::setEnterCriticalSectionCounter;
+    using ShardCollectionTypeBase::setNss;
+    using ShardCollectionTypeBase::setRefreshing;
+    using ShardCollectionTypeBase::setUnique;
+    using ShardCollectionTypeBase::setUuid;
 
     ShardCollectionType() : ShardCollectionTypeBase() {}
 
diff --git a/src/mongo/s/catalog/type_shard_database.cpp b/src/mongo/s/catalog/type_shard_database.cpp
index 268460023e2..059516dc3ac 100644
--- a/src/mongo/s/catalog/type_shard_database.cpp
+++ b/src/mongo/s/catalog/type_shard_database.cpp
@@ -65,10 +65,10 @@ StatusWith<ShardDatabaseType> ShardDatabaseType::fromBSON(const BSONObj& source)
         BSONObj versionField = source.getObjectField("version");
         if (versionField.isEmpty()) {
             return Status{ErrorCodes::InternalError,
-                          str::stream() << "DatabaseVersion doesn't exist in database entry "
-                                        << source
-                                        << " despite the shard being in binary version 4.2 or "
-                                           "later."};
+                          str::stream()
+                              << "DatabaseVersion doesn't exist in database entry " << source
+                              << " despite the shard being in binary version 4.2 or "
+                                 "later."};
         }
         dbVersion = DatabaseVersion::parse(IDLParserErrorContext("DatabaseType"), versionField);
     }
diff --git a/src/mongo/s/catalog/type_shard_test.cpp b/src/mongo/s/catalog/type_shard_test.cpp
index b39725e9c0f..d2c9ab0326e 100644
--- a/src/mongo/s/catalog/type_shard_test.cpp
+++ b/src/mongo/s/catalog/type_shard_test.cpp
@@ -62,9 +62,9 @@ TEST(ShardType, OnlyMandatory) {
 }
 
 TEST(ShardType, AllOptionalsPresent) {
-    BSONObj obj = BSON(ShardType::name("shard0000") << ShardType::host("localhost:27017")
-                                                    << ShardType::draining(true)
-                                                    << ShardType::maxSizeMB(100));
+    BSONObj obj = BSON(ShardType::name("shard0000")
+                       << ShardType::host("localhost:27017") << ShardType::draining(true)
+                       << ShardType::maxSizeMB(100));
     StatusWith<ShardType> shardRes = ShardType::fromBSON(obj);
     ASSERT(shardRes.isOK());
     ShardType shard = shardRes.getValue();
@@ -72,9 +72,8 @@ TEST(ShardType, AllOptionalsPresent) {
 }
 
 TEST(ShardType, MaxSizeAsFloat) {
-    BSONObj obj = BSON(ShardType::name("shard0000") << ShardType::host("localhost:27017")
-                                                    << ShardType::maxSizeMB()
-                                                    << 100.0);
+    BSONObj obj = BSON(ShardType::name("shard0000")
+                       << ShardType::host("localhost:27017") << ShardType::maxSizeMB() << 100.0);
     StatusWith<ShardType> shardRes = ShardType::fromBSON(obj);
     ASSERT(shardRes.isOK());
     ShardType shard = shardRes.getValue();
diff --git a/src/mongo/s/catalog/type_tags_test.cpp b/src/mongo/s/catalog/type_tags_test.cpp
index f466fc234ae..1cd8ed6d276 100644
--- a/src/mongo/s/catalog/type_tags_test.cpp
+++ b/src/mongo/s/catalog/type_tags_test.cpp
@@ -58,8 +58,8 @@ TEST(TagsType, Valid) {
 }
 
 TEST(TagsType, MissingNsField) {
-    BSONObj obj = BSON(TagsType::tag("tag") << TagsType::min(BSON("a" << 10))
-                                            << TagsType::max(BSON("a" << 20)));
+    BSONObj obj = BSON(TagsType::tag("tag")
+                       << TagsType::min(BSON("a" << 10)) << TagsType::max(BSON("a" << 20)));
 
     StatusWith<TagsType> status = TagsType::fromBSON(obj);
     ASSERT_FALSE(status.isOK());
@@ -67,8 +67,8 @@ TEST(TagsType, MissingNsField) {
 }
 
 TEST(TagsType, MissingTagField) {
-    BSONObj obj = BSON(TagsType::ns("test.mycol") << TagsType::min(BSON("a" << 10))
-                                                  << TagsType::max(BSON("a" << 20)));
+    BSONObj obj = BSON(TagsType::ns("test.mycol")
+                       << TagsType::min(BSON("a" << 10)) << TagsType::max(BSON("a" << 20)));
 
     StatusWith<TagsType> status = TagsType::fromBSON(obj);
     ASSERT_FALSE(status.isOK());
@@ -94,9 +94,9 @@ TEST(TagsType, MissingMaxKey) {
 }
 
 TEST(TagsType, KeysWithDifferentNumberOfColumns) {
-    BSONObj obj = BSON(TagsType::ns("test.mycol") << TagsType::tag("tag")
-                                                  << TagsType::min(BSON("a" << 10 << "b" << 10))
-                                                  << TagsType::max(BSON("a" << 20)));
+    BSONObj obj = BSON(TagsType::ns("test.mycol")
+                       << TagsType::tag("tag") << TagsType::min(BSON("a" << 10 << "b" << 10))
+                       << TagsType::max(BSON("a" << 20)));
 
     StatusWith<TagsType> status = TagsType::fromBSON(obj);
     const TagsType& tag = status.getValue();