[libc++][NFC] Apply clang-format on large parts of the code base

This commit does a pass of clang-format over files in libc++ that
don't require major changes to conform to our style guide, or for
which we're not overly concerned about conflicting with in-flight
patches or hindering the git blame.

This roughly covers:
- benchmarks
- range algorithms
- concepts
- type traits

I did a manual verification of all the changes, and in particular I
applied clang-format on/off annotations in a few places where the
result was less readable after than before. This was not necessary
in a lot of places, however I did find that clang-format had pretty
bad taste when it comes to formatting concepts.

Differential Revision: https://reviews.llvm.org/D153140

Author: ldionne

Diff for: libcxx/benchmarks/CartesianBenchmarks.h

@@ -6,7 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <string>
 #include <tuple>
 #include <type_traits>
@@ -22,7 +21,7 @@ struct EnumValue : std::integral_constant<E, static_cast<E>(I)> {
   static std::string name() { return std::string("_") + D::Names[I]; }
 };
 
-template <class D, class E, size_t ...Idxs>
+template <class D, class E, size_t... Idxs>
 constexpr auto makeEnumValueTuple(std::index_sequence<Idxs...>) {
   return std::make_tuple(EnumValue<D, E, Idxs>{}...);
 }
@@ -41,8 +40,7 @@ void makeBenchmarkFromValuesImpl(const Args& A, std::index_sequence<Is...>) {
   for (auto& V : A) {
     B Bench{std::get<Is>(V)...};
     if (!internal::skip(Bench, 0)) {
-      benchmark::RegisterBenchmark(Bench.name().c_str(),
-                                   [=](benchmark::State& S) { Bench.run(S); });
+      benchmark::RegisterBenchmark(Bench.name().c_str(), [=](benchmark::State& S) { Bench.run(S); });
     }
   }
 }
@@ -57,10 +55,8 @@ void makeBenchmarkImpl(const Args& A, std::tuple<U...> t) {
   makeBenchmarkFromValues<B<U...> >(A);
 }
 
-template <template <class...> class B, class Args, class... U,
-          class... T, class... Tuples>
-void makeBenchmarkImpl(const Args& A, std::tuple<U...>, std::tuple<T...>,
-                       Tuples... rest) {
+template <template <class...> class B, class Args, class... U, class... T, class... Tuples>
+void makeBenchmarkImpl(const Args& A, std::tuple<U...>, std::tuple<T...>, Tuples... rest) {
   (internal::makeBenchmarkImpl<B>(A, std::tuple<U..., T>(), rest...), ...);
 }
 
@@ -70,15 +66,13 @@ void allValueCombinations(R& Result, const T& Final) {
 }
 
 template <class R, class T, class V, class... Vs>
-void allValueCombinations(R& Result, const T& Prev, const V& Value,
-                          const Vs&... Values) {
+void allValueCombinations(R& Result, const T& Prev, const V& Value, const Vs&... Values) {
   for (const auto& E : Value) {
-    allValueCombinations(Result, std::tuple_cat(Prev, std::make_tuple(E)),
-                         Values...);
+    allValueCombinations(Result, std::tuple_cat(Prev, std::make_tuple(E)), Values...);
   }
 }
 
-}  // namespace internal
+} // namespace internal
 
 // CRTP class that enables using enum types as a dimension for
 // makeCartesianProductBenchmark below.
@@ -93,8 +87,7 @@ void allValueCombinations(R& Result, const T& Prev, const V& Value,
 // };
 template <class Derived, class EnumType, size_t NumLabels>
 using EnumValuesAsTuple =
-    decltype(internal::makeEnumValueTuple<Derived, EnumType>(
-        std::make_index_sequence<NumLabels>{}));
+    decltype(internal::makeEnumValueTuple<Derived, EnumType>(std::make_index_sequence<NumLabels>{}));
 
 // Instantiates B<T0, T1, ..., TN> where <Ti...> are the combinations in the
 // cartesian product of `Tuples...`, and pass (arg0, ..., argN) as constructor
@@ -128,6 +121,7 @@ int makeCartesianProductBenchmark(const Args&... A) {
 // It returns `value`.
 template <class T>
 TEST_ALWAYS_INLINE inline T maybeOpaque(T value, bool opaque) {
-  if (opaque) benchmark::DoNotOptimize(value);
+  if (opaque)
+    benchmark::DoNotOptimize(value);
   return value;
 }

Diff for: libcxx/benchmarks/ContainerBenchmarks.h

@@ -59,116 +59,114 @@ void BM_ConstructSizeValue(benchmark::State& st, Container, typename Container::
 
 template <class Container, class GenInputs>
 void BM_ConstructIterIter(benchmark::State& st, Container, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto begin = in.begin();
-    const auto end = in.end();
-    benchmark::DoNotOptimize(&in);
-    while (st.KeepRunning()) {
-        Container c(begin, end);
-        DoNotOptimizeData(c);
-    }
+  auto in          = gen(st.range(0));
+  const auto begin = in.begin();
+  const auto end   = in.end();
+  benchmark::DoNotOptimize(&in);
+  while (st.KeepRunning()) {
+    Container c(begin, end);
+    DoNotOptimizeData(c);
+  }
 }
 
 template <class Container, class GenInputs>
 void BM_InsertValue(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.end();
-    while (st.KeepRunning()) {
-        c.clear();
-        for (auto it = in.begin(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.insert(*it).first));
-        }
-        benchmark::ClobberMemory();
+  auto in        = gen(st.range(0));
+  const auto end = in.end();
+  while (st.KeepRunning()) {
+    c.clear();
+    for (auto it = in.begin(); it != end; ++it) {
+      benchmark::DoNotOptimize(&(*c.insert(*it).first));
     }
+    benchmark::ClobberMemory();
+  }
 }
 
 template <class Container, class GenInputs>
 void BM_InsertValueRehash(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.end();
-    while (st.KeepRunning()) {
-        c.clear();
-        c.rehash(16);
-        for (auto it = in.begin(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.insert(*it).first));
-        }
-        benchmark::ClobberMemory();
+  auto in        = gen(st.range(0));
+  const auto end = in.end();
+  while (st.KeepRunning()) {
+    c.clear();
+    c.rehash(16);
+    for (auto it = in.begin(); it != end; ++it) {
+      benchmark::DoNotOptimize(&(*c.insert(*it).first));
     }
+    benchmark::ClobberMemory();
+  }
 }
 
-
 template <class Container, class GenInputs>
 void BM_InsertDuplicate(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.end();
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(&c);
-    benchmark::DoNotOptimize(&in);
-    while (st.KeepRunning()) {
-        for (auto it = in.begin(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.insert(*it).first));
-        }
-        benchmark::ClobberMemory();
+  auto in        = gen(st.range(0));
+  const auto end = in.end();
+  c.insert(in.begin(), in.end());
+  benchmark::DoNotOptimize(&c);
+  benchmark::DoNotOptimize(&in);
+  while (st.KeepRunning()) {
+    for (auto it = in.begin(); it != end; ++it) {
+      benchmark::DoNotOptimize(&(*c.insert(*it).first));
     }
+    benchmark::ClobberMemory();
+  }
 }
 
-
 template <class Container, class GenInputs>
 void BM_EmplaceDuplicate(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    const auto end = in.end();
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(&c);
-    benchmark::DoNotOptimize(&in);
-    while (st.KeepRunning()) {
-        for (auto it = in.begin(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.emplace(*it).first));
-        }
-        benchmark::ClobberMemory();
+  auto in        = gen(st.range(0));
+  const auto end = in.end();
+  c.insert(in.begin(), in.end());
+  benchmark::DoNotOptimize(&c);
+  benchmark::DoNotOptimize(&in);
+  while (st.KeepRunning()) {
+    for (auto it = in.begin(); it != end; ++it) {
+      benchmark::DoNotOptimize(&(*c.emplace(*it).first));
     }
+    benchmark::ClobberMemory();
+  }
 }
 
 template <class Container, class GenInputs>
 static void BM_Find(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(&(*c.begin()));
-    const auto end = in.data() + in.size();
-    while (st.KeepRunning()) {
-        for (auto it = in.data(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.find(*it)));
-        }
-        benchmark::ClobberMemory();
+  auto in = gen(st.range(0));
+  c.insert(in.begin(), in.end());
+  benchmark::DoNotOptimize(&(*c.begin()));
+  const auto end = in.data() + in.size();
+  while (st.KeepRunning()) {
+    for (auto it = in.data(); it != end; ++it) {
+      benchmark::DoNotOptimize(&(*c.find(*it)));
     }
+    benchmark::ClobberMemory();
+  }
 }
 
 template <class Container, class GenInputs>
 static void BM_FindRehash(benchmark::State& st, Container c, GenInputs gen) {
-    c.rehash(8);
-    auto in = gen(st.range(0));
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(&(*c.begin()));
-    const auto end = in.data() + in.size();
-    while (st.KeepRunning()) {
-        for (auto it = in.data(); it != end; ++it) {
-            benchmark::DoNotOptimize(&(*c.find(*it)));
-        }
-        benchmark::ClobberMemory();
+  c.rehash(8);
+  auto in = gen(st.range(0));
+  c.insert(in.begin(), in.end());
+  benchmark::DoNotOptimize(&(*c.begin()));
+  const auto end = in.data() + in.size();
+  while (st.KeepRunning()) {
+    for (auto it = in.data(); it != end; ++it) {
+      benchmark::DoNotOptimize(&(*c.find(*it)));
     }
+    benchmark::ClobberMemory();
+  }
 }
 
 template <class Container, class GenInputs>
 static void BM_Rehash(benchmark::State& st, Container c, GenInputs gen) {
-    auto in = gen(st.range(0));
-    c.max_load_factor(3.0);
-    c.insert(in.begin(), in.end());
-    benchmark::DoNotOptimize(c);
-    const auto bucket_count = c.bucket_count();
-    while (st.KeepRunning()) {
-        c.rehash(bucket_count + 1);
-        c.rehash(bucket_count);
-        benchmark::ClobberMemory();
-    }
+  auto in = gen(st.range(0));
+  c.max_load_factor(3.0);
+  c.insert(in.begin(), in.end());
+  benchmark::DoNotOptimize(c);
+  const auto bucket_count = c.bucket_count();
+  while (st.KeepRunning()) {
+    c.rehash(bucket_count + 1);
+    c.rehash(bucket_count);
+    benchmark::ClobberMemory();
+  }
 }
 
 } // end namespace ContainerBenchmarks