SERVER-41772 Apply clang-format 7.0.1 to the codebase

9 files changed, 71 insertions, 129 deletions

diff --git a/src/mongo/db/geo/big_polygon.cpp b/src/mongo/db/geo/big_polygon.cpp
index 4f76faac823..e68191c7ff5 100644
--- a/src/mongo/db/geo/big_polygon.cpp
+++ b/src/mongo/db/geo/big_polygon.cpp
@@ -228,4 +228,4 @@ bool BigSimplePolygon::Decode(Decoder* const decoder) {
 bool BigSimplePolygon::DecodeWithinScope(Decoder* const decoder) {
     MONGO_UNREACHABLE;
 }
-}
+}  // namespace mongo
diff --git a/src/mongo/db/geo/big_polygon.h b/src/mongo/db/geo/big_polygon.h
index bc0e4ce75f1..6df8d3e4fd9 100644
--- a/src/mongo/db/geo/big_polygon.h
+++ b/src/mongo/db/geo/big_polygon.h
@@ -115,4 +115,4 @@ private:
     mutable std::unique_ptr<S2Polyline> _borderLine;
     mutable std::unique_ptr<S2Polygon> _borderPoly;
 };
-}
+}  // namespace mongo
diff --git a/src/mongo/db/geo/big_polygon_test.cpp b/src/mongo/db/geo/big_polygon_test.cpp
index b29b7c3eb4a..2a42706906d 100644
--- a/src/mongo/db/geo/big_polygon_test.cpp
+++ b/src/mongo/db/geo/big_polygon_test.cpp
@@ -36,8 +36,8 @@
 namespace {
 
 using namespace mongo;
-using std::unique_ptr;
 using std::string;
+using std::unique_ptr;
 using std::vector;
 
 // Helper to build a vector of S2Point
@@ -81,8 +81,7 @@ typedef PointBuilder points;
 TEST(BigSimplePolygon, Basic) {
     // A 20x20 square centered at [0,0]
     BigSimplePolygon bigPoly20(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                             << LatLng(-10.0, -10.0)
-                                             << LatLng(-10.0, 10.0)));
+                                             << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
 
     // A 10x10 square centered at [0,0]
     S2Polygon poly10(loopVec(points() << LatLng(5.0, 5.0) << LatLng(5.0, -5.0) << LatLng(-5.0, -5.0)
@@ -95,8 +94,7 @@ TEST(BigSimplePolygon, Basic) {
 
     // A 20x20 square centered at [0,20]
     BigSimplePolygon bigPoly20Offset(loop(points() << LatLng(10.0, 30.0) << LatLng(10.0, 10.0)
-                                                   << LatLng(-10.0, 10.0)
-                                                   << LatLng(-10.0, 30.0)));
+                                                   << LatLng(-10.0, 10.0) << LatLng(-10.0, 30.0)));
 
     ASSERT_LESS_THAN(bigPoly20Offset.GetArea(), 2 * M_PI);
     ASSERT_LESS_THAN(poly10.GetArea(), bigPoly20Offset.GetArea());
@@ -108,18 +106,15 @@ TEST(BigSimplePolygon, BasicWithHole) {
     // A 30x30 square centered at [0,0] with a 20X20 hole
     vector<S2Loop*> loops;
     loops.push_back(loop(points() << LatLng(15.0, 15.0) << LatLng(15.0, -15.0)
-                                  << LatLng(-15.0, -15.0)
-                                  << LatLng(-15.0, 15.0)));
+                                  << LatLng(-15.0, -15.0) << LatLng(-15.0, 15.0)));
     loops.push_back(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                  << LatLng(-10.0, -10.0)
-                                  << LatLng(-10.0, 10.0)));
+                                  << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
 
     S2Polygon holePoly(&loops);
 
     // A 16X16 square centered at [0,0]
     BigSimplePolygon bigPoly16(loop(points() << LatLng(8.0, 8.0) << LatLng(8.0, -8.0)
-                                             << LatLng(-8.0, -8.0)
-                                             << LatLng(-8.0, 8.0)));
+                                             << LatLng(-8.0, -8.0) << LatLng(-8.0, 8.0)));
 
     ASSERT_LESS_THAN(bigPoly16.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly16.Contains(holePoly));
@@ -127,8 +122,7 @@ TEST(BigSimplePolygon, BasicWithHole) {
 
     // A big polygon bigger than the hole.
     BigSimplePolygon bigPoly24(loop(points() << LatLng(12.0, 12.0) << LatLng(12.0, -12.0)
-                                             << LatLng(-12.0, -12.0)
-                                             << LatLng(-12.0, 12.0)));
+                                             << LatLng(-12.0, -12.0) << LatLng(-12.0, 12.0)));
     ASSERT_LESS_THAN(bigPoly24.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly24.Contains(holePoly));
     ASSERT_TRUE(bigPoly24.Intersects(holePoly));
@@ -139,12 +133,10 @@ TEST(BigSimplePolygon, BasicWithHoleAndShell) {
     vector<S2Loop*> loops;
     // Border
     loops.push_back(loop(points() << LatLng(15.0, 15.0) << LatLng(15.0, -15.0)
-                                  << LatLng(-15.0, -15.0)
-                                  << LatLng(-15.0, 15.0)));
+                                  << LatLng(-15.0, -15.0) << LatLng(-15.0, 15.0)));
     // Hole
     loops.push_back(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                  << LatLng(-10.0, -10.0)
-                                  << LatLng(-10.0, 10.0)));
+                                  << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
     // Shell
     loops.push_back(loop(points() << LatLng(5.0, 5.0) << LatLng(5.0, -5.0) << LatLng(-5.0, -5.0)
                                   << LatLng(-5.0, 5.0)));
@@ -152,24 +144,21 @@ TEST(BigSimplePolygon, BasicWithHoleAndShell) {
 
     // A 16X16 square centered at [0,0] containing the shell
     BigSimplePolygon bigPoly16(loop(points() << LatLng(8.0, 8.0) << LatLng(8.0, -8.0)
-                                             << LatLng(-8.0, -8.0)
-                                             << LatLng(-8.0, 8.0)));
+                                             << LatLng(-8.0, -8.0) << LatLng(-8.0, 8.0)));
     ASSERT_LESS_THAN(bigPoly16.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly16.Contains(shellPoly));
     ASSERT_TRUE(bigPoly16.Intersects(shellPoly));
 
     // Try a big polygon bigger than the hole.
     BigSimplePolygon bigPoly24(loop(points() << LatLng(12.0, 12.0) << LatLng(12.0, -12.0)
-                                             << LatLng(-12.0, -12.0)
-                                             << LatLng(-12.0, 12.0)));
+                                             << LatLng(-12.0, -12.0) << LatLng(-12.0, 12.0)));
     ASSERT_LESS_THAN(bigPoly24.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly24.Contains(shellPoly));
     ASSERT_TRUE(bigPoly24.Intersects(shellPoly));
 
     // Try a big polygon smaller than the shell.
     BigSimplePolygon bigPoly8(loop(points() << LatLng(4.0, 4.0) << LatLng(4.0, -4.0)
-                                            << LatLng(-4.0, -4.0)
-                                            << LatLng(-4.0, 4.0)));
+                                            << LatLng(-4.0, -4.0) << LatLng(-4.0, 4.0)));
     ASSERT_LESS_THAN(bigPoly8.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly8.Contains(shellPoly));
     ASSERT_TRUE(bigPoly8.Intersects(shellPoly));
@@ -178,8 +167,7 @@ TEST(BigSimplePolygon, BasicWithHoleAndShell) {
 TEST(BigSimplePolygon, BasicComplement) {
     // Everything *not* in a 20x20 square centered at [0,0]
     BigSimplePolygon bigPoly20Comp(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                                 << LatLng(-10.0, -10.0)
-                                                 << LatLng(-10.0, 10.0)));
+                                                 << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
     bigPoly20Comp.Invert();
 
     // A 10x10 square centered at [0,0]
@@ -192,8 +180,7 @@ TEST(BigSimplePolygon, BasicComplement) {
 
     // A 10x10 square centered at [0,20], contained by bigPoly20Comp
     S2Polygon poly10Contained(loopVec(points() << LatLng(25.0, 25.0) << LatLng(25.0, 15.0)
-                                               << LatLng(15.0, 15.0)
-                                               << LatLng(15.0, 25.0)));
+                                               << LatLng(15.0, 15.0) << LatLng(15.0, 25.0)));
 
     ASSERT_LESS_THAN(poly10Contained.GetArea(), bigPoly20Comp.GetArea());
     ASSERT(bigPoly20Comp.Contains(poly10Contained));
@@ -202,8 +189,7 @@ TEST(BigSimplePolygon, BasicComplement) {
     // A 30x30 square centered at [0,0], so that bigPoly20Comp contains its complement entirely,
     // which is not allowed by S2.
     S2Polygon poly30(loopVec(points() << LatLng(15.0, 15.0) << LatLng(15.0, -15.0)
-                                      << LatLng(-15.0, -15.0)
-                                      << LatLng(-15.0, 15.0)));
+                                      << LatLng(-15.0, -15.0) << LatLng(-15.0, 15.0)));
     ASSERT_LESS_THAN(poly30.GetArea(), bigPoly20Comp.GetArea());
     ASSERT_FALSE(bigPoly20Comp.Contains(poly30));
     ASSERT_TRUE(bigPoly20Comp.Intersects(poly30));
@@ -212,8 +198,7 @@ TEST(BigSimplePolygon, BasicComplement) {
 TEST(BigSimplePolygon, BasicIntersects) {
     // Everything *not* in a 20x20 square centered at [0,0]
     BigSimplePolygon bigPoly20(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                             << LatLng(-10.0, -10.0)
-                                             << LatLng(-10.0, 10.0)));
+                                             << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
     bigPoly20.Invert();
 
     // A 10x10 square centered at [10,10] (partial overlap)
@@ -228,19 +213,16 @@ TEST(BigSimplePolygon, BasicComplementWithHole) {
     // A 30x30 square centered at [0,0] with a 20X20 hole
     vector<S2Loop*> loops;
     loops.push_back(loop(points() << LatLng(15.0, 15.0) << LatLng(15.0, -15.0)
-                                  << LatLng(-15.0, -15.0)
-                                  << LatLng(-15.0, 15.0)));
+                                  << LatLng(-15.0, -15.0) << LatLng(-15.0, 15.0)));
     loops.push_back(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                  << LatLng(-10.0, -10.0)
-                                  << LatLng(-10.0, 10.0)));
+                                  << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
 
     S2Polygon holePoly(&loops);
 
     // 1. BigPolygon doesn't touch holePoly
     // Everything *not* in a 40x40 square centered at [0,0]
     BigSimplePolygon bigPoly40Comp(loop(points() << LatLng(20.0, 20.0) << LatLng(20.0, -20.0)
-                                                 << LatLng(-20.0, -20.0)
-                                                 << LatLng(-20.0, 20.0)));
+                                                 << LatLng(-20.0, -20.0) << LatLng(-20.0, 20.0)));
     bigPoly40Comp.Invert();
     ASSERT_GREATER_THAN(bigPoly40Comp.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly40Comp.Contains(holePoly));
@@ -249,8 +231,7 @@ TEST(BigSimplePolygon, BasicComplementWithHole) {
     // 2. BigPolygon intersects holePoly
     // Everything *not* in a 24X24 square centered at [0,0]
     BigSimplePolygon bigPoly24Comp(loop(points() << LatLng(12.0, 12.0) << LatLng(12.0, -12.0)
-                                                 << LatLng(-12.0, -12.0)
-                                                 << LatLng(-12.0, 12.0)));
+                                                 << LatLng(-12.0, -12.0) << LatLng(-12.0, 12.0)));
     bigPoly24Comp.Invert();
     ASSERT_GREATER_THAN(bigPoly24Comp.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly24Comp.Contains(holePoly));
@@ -259,8 +240,7 @@ TEST(BigSimplePolygon, BasicComplementWithHole) {
     // 3. BigPolygon contains holePoly
     // Everything *not* in a 16X16 square centered at [0,0]
     BigSimplePolygon bigPoly16Comp(loop(points() << LatLng(8.0, 8.0) << LatLng(8.0, -8.0)
-                                                 << LatLng(-8.0, -8.0)
-                                                 << LatLng(-8.0, 8.0)));
+                                                 << LatLng(-8.0, -8.0) << LatLng(-8.0, 8.0)));
     bigPoly16Comp.Invert();
     ASSERT_GREATER_THAN(bigPoly16Comp.GetArea(), 2 * M_PI);
     ASSERT_TRUE(bigPoly16Comp.Contains(holePoly));
@@ -268,9 +248,9 @@ TEST(BigSimplePolygon, BasicComplementWithHole) {
 
     // 4. BigPolygon contains the right half of holePoly
     // Everything *not* in a 40x40 square centered at [0,20]
-    BigSimplePolygon bigPoly40CompOffset(loop(points() << LatLng(20.0, 40.0) << LatLng(20.0, 0.0)
-                                                       << LatLng(-20.0, 0.0)
-                                                       << LatLng(-20.0, 40.0)));
+    BigSimplePolygon bigPoly40CompOffset(loop(points()
+                                              << LatLng(20.0, 40.0) << LatLng(20.0, 0.0)
+                                              << LatLng(-20.0, 0.0) << LatLng(-20.0, 40.0)));
     bigPoly40CompOffset.Invert();
     ASSERT_GREATER_THAN(bigPoly40CompOffset.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly40CompOffset.Contains(holePoly));
@@ -282,12 +262,10 @@ TEST(BigSimplePolygon, BasicComplementWithHoleAndShell) {
     vector<S2Loop*> loops;
     // Border
     loops.push_back(loop(points() << LatLng(15.0, 15.0) << LatLng(15.0, -15.0)
-                                  << LatLng(-15.0, -15.0)
-                                  << LatLng(-15.0, 15.0)));
+                                  << LatLng(-15.0, -15.0) << LatLng(-15.0, 15.0)));
     // Hole
     loops.push_back(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                  << LatLng(-10.0, -10.0)
-                                  << LatLng(-10.0, 10.0)));
+                                  << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
     // Shell
     loops.push_back(loop(points() << LatLng(5.0, 5.0) << LatLng(5.0, -5.0) << LatLng(-5.0, -5.0)
                                   << LatLng(-5.0, 5.0)));
@@ -296,8 +274,7 @@ TEST(BigSimplePolygon, BasicComplementWithHoleAndShell) {
     // 1. BigPolygon doesn't touch shellPoly
     // Everything *not* in a 40x40 square centered at [0,0]
     BigSimplePolygon bigPoly40Comp(loop(points() << LatLng(20.0, 20.0) << LatLng(20.0, -20.0)
-                                                 << LatLng(-20.0, -20.0)
-                                                 << LatLng(-20.0, 20.0)));
+                                                 << LatLng(-20.0, -20.0) << LatLng(-20.0, 20.0)));
     bigPoly40Comp.Invert();
     ASSERT_GREATER_THAN(bigPoly40Comp.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly40Comp.Contains(shellPoly));
@@ -306,8 +283,7 @@ TEST(BigSimplePolygon, BasicComplementWithHoleAndShell) {
     // 2. BigPolygon intersects shellPoly
     // Everything *not* in a 24X24 square centered at [0,0]
     BigSimplePolygon bigPoly24Comp(loop(points() << LatLng(12.0, 12.0) << LatLng(12.0, -12.0)
-                                                 << LatLng(-12.0, -12.0)
-                                                 << LatLng(-12.0, 12.0)));
+                                                 << LatLng(-12.0, -12.0) << LatLng(-12.0, 12.0)));
     bigPoly24Comp.Invert();
     ASSERT_GREATER_THAN(bigPoly24Comp.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly24Comp.Contains(shellPoly));
@@ -316,8 +292,7 @@ TEST(BigSimplePolygon, BasicComplementWithHoleAndShell) {
     // 3. BigPolygon contains shellPoly's outer ring
     // Everything *not* in a 16X16 square centered at [0,0]
     BigSimplePolygon bigPoly16Comp(loop(points() << LatLng(8.0, 8.0) << LatLng(8.0, -8.0)
-                                                 << LatLng(-8.0, -8.0)
-                                                 << LatLng(-8.0, 8.0)));
+                                                 << LatLng(-8.0, -8.0) << LatLng(-8.0, 8.0)));
     bigPoly16Comp.Invert();
     ASSERT_GREATER_THAN(bigPoly16Comp.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly16Comp.Contains(shellPoly));
@@ -325,9 +300,9 @@ TEST(BigSimplePolygon, BasicComplementWithHoleAndShell) {
 
     // 4. BigPolygon contains the right half of shellPoly
     // Everything *not* in a 40x40 square centered at [0,20]
-    BigSimplePolygon bigPoly40CompOffset(loop(points() << LatLng(20.0, 40.0) << LatLng(20.0, 0.0)
-                                                       << LatLng(-20.0, 0.0)
-                                                       << LatLng(-20.0, 40.0)));
+    BigSimplePolygon bigPoly40CompOffset(loop(points()
+                                              << LatLng(20.0, 40.0) << LatLng(20.0, 0.0)
+                                              << LatLng(-20.0, 0.0) << LatLng(-20.0, 40.0)));
     bigPoly40CompOffset.Invert();
     ASSERT_GREATER_THAN(bigPoly40CompOffset.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly40CompOffset.Contains(shellPoly));
@@ -335,8 +310,7 @@ TEST(BigSimplePolygon, BasicComplementWithHoleAndShell) {
 
     // 5. BigPolygon contain shellPoly (CW)
     BigSimplePolygon bigPolyCompOffset(loop(points() << LatLng(6.0, 6.0) << LatLng(6.0, 8.0)
-                                                     << LatLng(-6.0, 8.0)
-                                                     << LatLng(-6.0, 6.0)));
+                                                     << LatLng(-6.0, 8.0) << LatLng(-6.0, 6.0)));
     ASSERT_GREATER_THAN(bigPolyCompOffset.GetArea(), 2 * M_PI);
     ASSERT_TRUE(bigPolyCompOffset.Contains(shellPoly));
     ASSERT_TRUE(bigPolyCompOffset.Intersects(shellPoly));
@@ -345,13 +319,11 @@ TEST(BigSimplePolygon, BasicComplementWithHoleAndShell) {
 TEST(BigSimplePolygon, BasicWinding) {
     // A 20x20 square centered at [0,0] (CCW)
     BigSimplePolygon bigPoly20(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                             << LatLng(-10.0, -10.0)
-                                             << LatLng(-10.0, 10.0)));
+                                             << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
 
     // Everything *not* in a 20x20 square centered at [0,0] (CW)
     BigSimplePolygon bigPoly20Comp(loop(points() << LatLng(10.0, 10.0) << LatLng(-10.0, 10.0)
-                                                 << LatLng(-10.0, -10.0)
-                                                 << LatLng(10.0, -10.0)));
+                                                 << LatLng(-10.0, -10.0) << LatLng(10.0, -10.0)));
 
     ASSERT_LESS_THAN(bigPoly20.GetArea(), 2 * M_PI);
     ASSERT_GREATER_THAN(bigPoly20Comp.GetArea(), 2 * M_PI);
@@ -360,13 +332,11 @@ TEST(BigSimplePolygon, BasicWinding) {
 TEST(BigSimplePolygon, LineRelations) {
     // A 20x20 square centered at [0,0]
     BigSimplePolygon bigPoly20(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                             << LatLng(-10.0, -10.0)
-                                             << LatLng(-10.0, 10.0)));
+                                             << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
 
     // A 10x10 line circling [0,0]
     S2Polyline line10(pointVec(points() << LatLng(5.0, 5.0) << LatLng(5.0, -5.0)
-                                        << LatLng(-5.0, -5.0)
-                                        << LatLng(-5.0, 5.0)));
+                                        << LatLng(-5.0, -5.0) << LatLng(-5.0, 5.0)));
 
     ASSERT_LESS_THAN(bigPoly20.GetArea(), 2 * M_PI);
     ASSERT(bigPoly20.Contains(line10));
@@ -386,14 +356,12 @@ TEST(BigSimplePolygon, LineRelations) {
 TEST(BigSimplePolygon, LineRelationsComplement) {
     // A 20x20 square centered at [0,0]
     BigSimplePolygon bigPoly20Comp(loop(points() << LatLng(10.0, 10.0) << LatLng(10.0, -10.0)
-                                                 << LatLng(-10.0, -10.0)
-                                                 << LatLng(-10.0, 10.0)));
+                                                 << LatLng(-10.0, -10.0) << LatLng(-10.0, 10.0)));
     bigPoly20Comp.Invert();
 
     // A 10x10 line circling [0,0]
     S2Polyline line10(pointVec(points() << LatLng(5.0, 5.0) << LatLng(5.0, -5.0)
-                                        << LatLng(-5.0, -5.0)
-                                        << LatLng(-5.0, 5.0)));
+                                        << LatLng(-5.0, -5.0) << LatLng(-5.0, 5.0)));
 
     ASSERT_GREATER_THAN(bigPoly20Comp.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly20Comp.Contains(line10));
@@ -406,8 +374,7 @@ TEST(BigSimplePolygon, LineRelationsComplement) {
 
     // A 10x10 line circling [0,0]
     S2Polyline line30(pointVec(points() << LatLng(15.0, 15.0) << LatLng(15.0, -15.0)
-                                        << LatLng(-15.0, -15.0)
-                                        << LatLng(-15.0, 15.0)));
+                                        << LatLng(-15.0, -15.0) << LatLng(-15.0, 15.0)));
     ASSERT_TRUE(bigPoly20Comp.Contains(line30));
     ASSERT_TRUE(bigPoly20Comp.Intersects(line30));
 }
@@ -415,13 +382,11 @@ TEST(BigSimplePolygon, LineRelationsComplement) {
 TEST(BigSimplePolygon, LineRelationsWinding) {
     // Everything *not* in a 20x20 square centered at [0,0] (CW winding)
     BigSimplePolygon bigPoly20Comp(loop(points() << LatLng(10.0, 10.0) << LatLng(-10.0, 10.0)
-                                                 << LatLng(-10.0, -10.0)
-                                                 << LatLng(10.0, -10.0)));
+                                                 << LatLng(-10.0, -10.0) << LatLng(10.0, -10.0)));
 
     // A 10x10 line circling [0,0]
     S2Polyline line10(pointVec(points() << LatLng(5.0, 5.0) << LatLng(5.0, -5.0)
-                                        << LatLng(-5.0, -5.0)
-                                        << LatLng(-5.0, 5.0)));
+                                        << LatLng(-5.0, -5.0) << LatLng(-5.0, 5.0)));
 
     ASSERT_GREATER_THAN(bigPoly20Comp.GetArea(), 2 * M_PI);
     ASSERT_FALSE(bigPoly20Comp.Contains(line10));
@@ -431,13 +396,11 @@ TEST(BigSimplePolygon, LineRelationsWinding) {
 TEST(BigSimplePolygon, PolarContains) {
     // Square 10 degrees from the north pole [90,0]
     BigSimplePolygon bigNorthPoly(loop(points() << LatLng(80.0, 0.0) << LatLng(80.0, 90.0)
-                                                << LatLng(80.0, 180.0)
-                                                << LatLng(80.0, -90.0)));
+                                                << LatLng(80.0, 180.0) << LatLng(80.0, -90.0)));
 
     // Square 5 degrees from the north pole [90, 0]
     S2Polygon northPoly(loopVec(points() << LatLng(85.0, 0.0) << LatLng(85.0, 90.0)
-                                         << LatLng(85.0, 180.0)
-                                         << LatLng(85.0, -90.0)));
+                                         << LatLng(85.0, 180.0) << LatLng(85.0, -90.0)));
 
     ASSERT_LESS_THAN(bigNorthPoly.GetArea(), 2 * M_PI);
     ASSERT_LESS_THAN(northPoly.GetArea(), bigNorthPoly.GetArea());
@@ -448,8 +411,7 @@ TEST(BigSimplePolygon, PolarContains) {
 TEST(BigSimplePolygon, PolarContainsWithHoles) {
     // Square 10 degrees from the north pole [90,0]
     BigSimplePolygon bigNorthPoly(loop(points() << LatLng(80.0, 0.0) << LatLng(80.0, 90.0)
-                                                << LatLng(80.0, 180.0)
-                                                << LatLng(80.0, -90.0)));
+                                                << LatLng(80.0, 180.0) << LatLng(80.0, -90.0)));
 
     // Square 5 degrees from the north pole [90, 0] with a concentric hole 1 degree from the
     // north pole
@@ -468,8 +430,7 @@ TEST(BigSimplePolygon, PolarContainsWithHoles) {
 TEST(BigSimplePolygon, PolarIntersectsWithHoles) {
     // Square 10 degrees from the north pole [90,0]
     BigSimplePolygon bigNorthPoly(loop(points() << LatLng(80.0, 0.0) << LatLng(80.0, 90.0)
-                                                << LatLng(80.0, 180.0)
-                                                << LatLng(80.0, -90.0)));
+                                                << LatLng(80.0, 180.0) << LatLng(80.0, -90.0)));
 
     // 5-degree square with 1-degree-wide concentric hole, centered on [80.0, 0.0]
     vector<S2Loop*> loops;
@@ -512,8 +473,7 @@ void checkConsistency(const BigSimplePolygon& bigPoly,
 TEST(BigSimplePolygon, ShareEdgeDisjoint) {
     // Big polygon smaller than a hemisphere.
     BigSimplePolygon bigPoly(loop(points() << LatLng(80.0, 0.0) << LatLng(-80.0, 0.0)
-                                           << LatLng(-80.0, 90.0)
-                                           << LatLng(80.0, 90.0)));
+                                           << LatLng(-80.0, 90.0) << LatLng(80.0, 90.0)));
     ASSERT_LESS_THAN(bigPoly.GetArea(), 2 * M_PI);
 
     // Vertex point and collinear point
@@ -522,12 +482,10 @@ TEST(BigSimplePolygon, ShareEdgeDisjoint) {
 
     // Polygon shares one edge
     S2Polygon poly(loopVec(points() << LatLng(80.0, 0.0) << LatLng(-80.0, 0.0)
-                                    << LatLng(-80.0, -10.0)
-                                    << LatLng(80.0, -10.0)));
+                                    << LatLng(-80.0, -10.0) << LatLng(80.0, -10.0)));
     // Polygon shares a segment of one edge
     S2Polygon collinearPoly(loopVec(points() << LatLng(50.0, 0.0) << LatLng(-50.0, 0.0)
-                                             << LatLng(-50.0, -10.0)
-                                             << LatLng(50.0, -10.0)));
+                                             << LatLng(-50.0, -10.0) << LatLng(50.0, -10.0)));
 
     // Line
     S2Polyline line(
@@ -538,12 +496,9 @@ TEST(BigSimplePolygon, ShareEdgeDisjoint) {
 
     // Big polygon larger than a hemisphere.
     BigSimplePolygon expandedBigPoly(loop(points() << LatLng(80.0, 0.0) << LatLng(-80.0, 0.0)
-                                                   << LatLng(-80.0, 90.0)
-                                                   << LatLng(-80.0, 180.0)
-                                                   << LatLng(-80.0, -90.0)
-                                                   << LatLng(80.0, -90.0)
-                                                   << LatLng(80.0, 180.0)
-                                                   << LatLng(80.0, 90.0)));
+                                                   << LatLng(-80.0, 90.0) << LatLng(-80.0, 180.0)
+                                                   << LatLng(-80.0, -90.0) << LatLng(80.0, -90.0)
+                                                   << LatLng(80.0, 180.0) << LatLng(80.0, 90.0)));
     ASSERT_GREATER_THAN(expandedBigPoly.GetArea(), 2 * M_PI);
 
     checkConsistency(bigPoly, expandedBigPoly, point);
@@ -571,18 +526,15 @@ TEST(BigSimplePolygon, ShareEdgeDisjoint) {
 TEST(BigSimplePolygon, ShareEdgeContained) {
     // Big polygon smaller than a hemisphere.
     BigSimplePolygon bigPoly(loop(points() << LatLng(80.0, 0.0) << LatLng(-80.0, 0.0)
-                                           << LatLng(-80.0, 90.0)
-                                           << LatLng(80.0, 90.0)));
+                                           << LatLng(-80.0, 90.0) << LatLng(80.0, 90.0)));
     ASSERT_LESS_THAN(bigPoly.GetArea(), 2 * M_PI);
 
     // Polygon
     S2Polygon poly(loopVec(points() << LatLng(80.0, 0.0) << LatLng(-80.0, 0.0)
-                                    << LatLng(-80.0, 10.0)
-                                    << LatLng(80.0, 10.0)));
+                                    << LatLng(-80.0, 10.0) << LatLng(80.0, 10.0)));
     // Polygon shares a segment of one edge
     S2Polygon collinearPoly(loopVec(points() << LatLng(50.0, 0.0) << LatLng(-50.0, 0.0)
-                                             << LatLng(-50.0, 10.0)
-                                             << LatLng(50.0, 10.0)));
+                                             << LatLng(-50.0, 10.0) << LatLng(50.0, 10.0)));
     // Line
     S2Polyline line(
         pointVec(points() << LatLng(80.0, 0.0) << LatLng(-80.0, 0.0) << LatLng(0.0, 10.0)));
@@ -592,12 +544,9 @@ TEST(BigSimplePolygon, ShareEdgeContained) {
 
     // Big polygon larger than a hemisphere.
     BigSimplePolygon expandedBigPoly(loop(points() << LatLng(80.0, 0.0) << LatLng(-80.0, 0.0)
-                                                   << LatLng(-80.0, 90.0)
-                                                   << LatLng(-80.0, 180.0)
-                                                   << LatLng(-80.0, -90.0)
-                                                   << LatLng(80.0, -90.0)
-                                                   << LatLng(80.0, 180.0)
-                                                   << LatLng(80.0, 90.0)));
+                                                   << LatLng(-80.0, 90.0) << LatLng(-80.0, 180.0)
+                                                   << LatLng(-80.0, -90.0) << LatLng(80.0, -90.0)
+                                                   << LatLng(80.0, 180.0) << LatLng(80.0, 90.0)));
     ASSERT_GREATER_THAN(expandedBigPoly.GetArea(), 2 * M_PI);
 
     checkConsistency(bigPoly, expandedBigPoly, poly);
@@ -616,4 +565,4 @@ TEST(BigSimplePolygon, ShareEdgeContained) {
     checkConsistency(bigPoly, expandedBigPoly, line);
     checkConsistency(bigPoly, expandedBigPoly, collinearLine);
 }
-}
+}  // namespace
diff --git a/src/mongo/db/geo/geoparser.cpp b/src/mongo/db/geo/geoparser.cpp
index 3db8485eb6e..1d8fef041ce 100644
--- a/src/mongo/db/geo/geoparser.cpp
+++ b/src/mongo/db/geo/geoparser.cpp
@@ -230,8 +230,7 @@ static Status parseGeoJSONPolygonCoordinates(const BSONElement& elem,
                 "Secondary loops not contained by first exterior loop - "
                 "secondary loops must be holes: "
                 << coordinateElt.toString(false)
-                << " first loop: "
-                << elem.Obj().firstElement().toString(false));
+                << " first loop: " << elem.Obj().firstElement().toString(false));
         }
     }
 
diff --git a/src/mongo/db/geo/geoparser_test.cpp b/src/mongo/db/geo/geoparser_test.cpp
index 921ba70e6d6..01eba23667a 100644
--- a/src/mongo/db/geo/geoparser_test.cpp
+++ b/src/mongo/db/geo/geoparser_test.cpp
@@ -434,4 +434,4 @@ TEST(GeoParser, parseGeometryCollection) {
         ASSERT_TRUE(gc.supportsContains());
     }
 }
-}
+}  // namespace
diff --git a/src/mongo/db/geo/hash.cpp b/src/mongo/db/geo/hash.cpp
index 761f8c79213..f8ebed9a7da 100644
--- a/src/mongo/db/geo/hash.cpp
+++ b/src/mongo/db/geo/hash.cpp
@@ -667,19 +667,13 @@ Status GeoHashConverter::parseParameters(const BSONObj& paramDoc,
     if (params->bits < 1 || params->bits > 32) {
         return Status(ErrorCodes::InvalidOptions,
                       str::stream() << "bits for hash must be > 0 and <= 32, "
-                                    << "but "
-                                    << params->bits
-                                    << " bits were specified");
+                                    << "but " << params->bits << " bits were specified");
     }
 
     if (params->min >= params->max) {
         return Status(ErrorCodes::InvalidOptions,
                       str::stream() << "region for hash must be valid and have positive area, "
-                                    << "but ["
-                                    << params->min
-                                    << ", "
-                                    << params->max
-                                    << "] "
+                                    << "but [" << params->min << ", " << params->max << "] "
                                     << "was specified");
     }
 
@@ -774,8 +768,7 @@ GeoHash GeoHashConverter::hash(const BSONObj& o, const BSONObj* src) const {
 GeoHash GeoHashConverter::hash(double x, double y) const {
     uassert(16433,
             str::stream() << "point not in interval of [ " << _params.min << ", " << _params.max
-                          << " ]"
-                          << causedBy(BSON_ARRAY(x << y).toString()),
+                          << " ]" << causedBy(BSON_ARRAY(x << y).toString()),
             x <= _params.max && x >= _params.min && y <= _params.max && y >= _params.min);
 
     return GeoHash(convertToHashScale(x), convertToHashScale(y), _params.bits);
diff --git a/src/mongo/db/geo/hash_test.cpp b/src/mongo/db/geo/hash_test.cpp
index 1681803083f..288a0895d02 100644
--- a/src/mongo/db/geo/hash_test.cpp
+++ b/src/mongo/db/geo/hash_test.cpp
@@ -549,4 +549,4 @@ TEST(GeoHash, ClearUnusedBitsIsNoopIfNoBitsAreUnused) {
     GeoHash other = geoHash.parent(32);
     ASSERT_EQUALS(geoHash, other);
 }
-}
+}  // namespace
diff --git a/src/mongo/db/geo/r2_region_coverer.cpp b/src/mongo/db/geo/r2_region_coverer.cpp
index 67ebbf37924..284350f62ab 100644
--- a/src/mongo/db/geo/r2_region_coverer.cpp
+++ b/src/mongo/db/geo/r2_region_coverer.cpp
@@ -332,7 +332,7 @@ void getDifferenceInternal(GeoHash cellId,
         }
     }
 }
-}
+}  // namespace
 
 void R2CellUnion::getDifference(const R2CellUnion& cellUnion) {
     std::vector<GeoHash> diffCellIds;
diff --git a/src/mongo/db/geo/shapes.h b/src/mongo/db/geo/shapes.h
index ca400eaa829..be466668110 100644
--- a/src/mongo/db/geo/shapes.h
+++ b/src/mongo/db/geo/shapes.h
@@ -64,8 +64,9 @@ inline double rad2deg(const double rad) {
 
 inline double computeXScanDistance(double y, double maxDistDegrees) {
     // TODO: this overestimates for large maxDistDegrees far from the equator
-    return maxDistDegrees / std::min(cos(deg2rad(std::min(+89.0, y + maxDistDegrees))),
-                                     cos(deg2rad(std::max(-89.0, y - maxDistDegrees))));
+    return maxDistDegrees /
+        std::min(cos(deg2rad(std::min(+89.0, y + maxDistDegrees))),
+                 cos(deg2rad(std::max(-89.0, y - maxDistDegrees))));
 }
 
 bool isValidLngLat(double lng, double lat);