Please consider the following formatting changes to #13664

Framework/Core/include/Framework/AnalysisHelpers.h

@@ -89,7 +89,7 @@ concept producable = soa::has_metadata<T> || soa::has_metadata<typename T::paren
 template <producable T>
 struct WritingCursor {
  public:
-  using persistent_table_t = decltype([](){ if constexpr (soa::is_iterator<T>) { return typename T::parent_t{nullptr}; } else { return T{nullptr}; } }());//std::conditional<soa::is_iterator<T>, typename T::parent_t, T>;
+  using persistent_table_t = decltype([]() { if constexpr (soa::is_iterator<T>) { return typename T::parent_t{nullptr}; } else { return T{nullptr}; } }());  // std::conditional<soa::is_iterator<T>, typename T::parent_t, T>;
   using cursor_t = decltype(std::declval<TableBuilder>().cursor<persistent_table_t>());
 
   template <typename... Ts>
@@ -133,7 +133,7 @@ struct WritingCursor {
 
   decltype(FFL(std::declval<cursor_t>())) cursor;
 
- private: 
+ private:
   template <typename A>
   static decltype(auto) extract(A const& arg)
   {

Framework/Core/include/Framework/AnalysisManagers.h

@@ -466,7 +466,7 @@ struct ServiceManager<Service<T>> {
   {
     // FIXME: for the moment we only need endOfStream to be
     // stateless. In the future we might want to pass it EndOfStreamContext
-    if constexpr (requires (T t) { t.endOfStream(); }) {
+    if constexpr (requires(T t) { t.endOfStream(); }) {
       service.service->endOfStream();
       return true;
     }

Framework/Core/include/Framework/AnalysisTask.h

@@ -85,8 +85,8 @@ struct AnalysisDataProcessorBuilder {
   template <soa::with_sources T>
   static inline auto getSources()
   {
-    return []<size_t N, std::array<soa::TableRef, N> refs>(){
-      return []<size_t... Is>(std::index_sequence<Is...>){
+    return []<size_t N, std::array<soa::TableRef, N> refs>() {
+      return []<size_t... Is>(std::index_sequence<Is...>) {
         return std::vector{soa::tableRef2ConfigParamSpec<refs[Is]>()...};
       }(std::make_index_sequence<N>());
     }.template operator()<T::sources.size(), T::sources>();
@@ -195,20 +195,20 @@ struct AnalysisDataProcessorBuilder {
   template <soa::is_table T>
   static auto extractFromRecord(InputRecord& record)
   {
-    return T{[&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>){ return std::vector{extractTableFromRecord<refs[Is]>(record)...}; }.template operator()<T::originals.size(), T::originals>(std::make_index_sequence<T::originals.size()>())};
+    return T { [&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::vector{extractTableFromRecord<refs[Is]>(record)...}; }.template operator()<T::originals.size(), T::originals>(std::make_index_sequence<T::originals.size()>()) };
   }
 
   template <soa::is_iterator T>
   static auto extractFromRecord(InputRecord& record)
   {
-    return typename T::parent_t{[&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>){ return std::vector{extractTableFromRecord<refs[Is]>(record)...}; }.template operator()<T::parent_t::originals.size(), T::parent_t::originals>(std::make_index_sequence<T::parent_t::originals.size()>())};
+    return typename T::parent_t { [&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::vector{extractTableFromRecord<refs[Is]>(record)...}; }.template operator()<T::parent_t::originals.size(), T::parent_t::originals>(std::make_index_sequence<T::parent_t::originals.size()>()) };
   }
 
   template <soa::is_filtered T>
   static auto extractFilteredFromRecord(InputRecord& record, ExpressionInfo& info)
   {
     std::shared_ptr<arrow::Table> table = nullptr;
-    auto joiner = [&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>){ return std::vector{extractTableFromRecord<refs[Is]>(record)...}; };
+    auto joiner = [&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::vector{extractTableFromRecord<refs[Is]>(record)...}; };
     if constexpr (soa::is_iterator<T>) {
       table = o2::soa::ArrowHelpers::joinTables(joiner.template operator()<T::parent_t::originals.size(), T::parent_t::originals>(std::make_index_sequence<T::parent_t::originals.size()>()));
     } else {

Framework/Core/include/Framework/TableBuilder.h

@@ -901,7 +901,8 @@ auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* na
   auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
   {
     return {{std::move(C::Projector())...}};
-  }(expression_pack_t{});
+  }
+  (expression_pack_t{});
 
   return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name);
 }
@@ -911,14 +912,15 @@ auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name)
 {
   using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
   if (fullTable->num_rows() == 0) {
-    return makeEmptyTable(name,expression_pack_t{});
+    return makeEmptyTable(name, expression_pack_t{});
   }
   static auto fields = o2::soa::createFieldsFromColumns(expression_pack_t{});
   static auto new_schema = std::make_shared<arrow::Schema>(fields);
   auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
   {
     return {{std::move(C::Projector())...}};
-  }(expression_pack_t{});
+  }
+  (expression_pack_t{});
 
   return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name);
 }

Framework/Core/src/ASoA.cxx

@@ -115,7 +115,7 @@ std::shared_ptr<arrow::Table> ArrowHelpers::concatTables(std::vector<std::shared
 
 arrow::ChunkedArray* getIndexFromLabel(arrow::Table* table, const char* label)
 {
-  auto field = std::find_if(table->schema()->fields().begin(), table->schema()->fields().end(), [&](std::shared_ptr<arrow::Field> const& f){
+  auto field = std::find_if(table->schema()->fields().begin(), table->schema()->fields().end(), [&](std::shared_ptr<arrow::Field> const& f) {
     return o2::framework::strToUpper(label) == o2::framework::strToUpper(std::string{f->name()});
   });
   if (field == table->schema()->fields().end()) {
@@ -155,7 +155,7 @@ std::string cutString(std::string&& str)
 
 std::string strToUpper(std::string&& str)
 {
-  std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c){ return std::toupper(c); });
+  std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) { return std::toupper(c); });
   return str;
 }
 } // namespace o2::framework

Framework/Core/test/test_AnalysisDataModel.cxx

@@ -31,7 +31,7 @@ DECLARE_SOA_COLUMN(D, d, float);
 
 DECLARE_SOA_TABLE(XY, "AOD", "XY", col::X, col::Y);
 DECLARE_SOA_TABLE(ZD, "AOD", "ZD", col::Z, col::D);
-}
+} // namespace o2::aod
 
 TEST_CASE("TestJoinedTablesContains")
 {

Framework/Core/test/test_TableSpawner.cxx

@@ -26,13 +26,13 @@ namespace test
 DECLARE_SOA_COLUMN(X, x, float);
 DECLARE_SOA_COLUMN(Y, y, float);
 DECLARE_SOA_COLUMN(Z, z, float);
-DECLARE_SOA_EXPRESSION_COLUMN(Rsq, rsq, float, test::x * test::x + test::y * test::y + test::z * test::z);
-DECLARE_SOA_EXPRESSION_COLUMN(Sin, sin, float, test::x / nsqrt (test::x * test::x + test::y * test::y));
-}
+DECLARE_SOA_EXPRESSION_COLUMN(Rsq, rsq, float, test::x* test::x + test::y * test::y + test::z * test::z);
+DECLARE_SOA_EXPRESSION_COLUMN(Sin, sin, float, test::x / nsqrt(test::x * test::x + test::y * test::y));
+} // namespace test
 
 DECLARE_SOA_TABLE(Points, "AOD", "PTSNG", test::X, test::Y, test::Z);
 DECLARE_SOA_EXTENDED_TABLE(ExPoints, Points, "EXPTSNG", 0, test::Rsq, test::Sin);
-}
+} // namespace o2::aod
 
 TEST_CASE("TestTableSpawner")
 {

Framework/Foundation/include/Framework/Pack.h

@@ -226,21 +226,21 @@ inline constexpr bool has_type_conditional_v = has_type_conditional<Condition, T
 template <typename T, typename... Ts>
 consteval size_t has_type_at_v(pack<Ts...>)
 {
-    constexpr size_t size = sizeof...(Ts);
-    constexpr bool found[size] = { std::same_as<T, Ts> ... };
-    for (size_t i = 0; i < size; ++i) {
-      if (found[i]) {
-        return i;
-      }
+  constexpr size_t size = sizeof...(Ts);
+  constexpr bool found[size] = {std::same_as<T, Ts>...};
+  for (size_t i = 0; i < size; ++i) {
+    if (found[i]) {
+      return i;
     }
-    return size + 1;
+  }
+  return size + 1;
 }
 
 template <template <typename, typename> typename Condition, typename T, typename... Ts>
 consteval size_t has_type_at_conditional_v(pack<Ts...>)
 {
   constexpr size_t size = sizeof...(Ts);
-  constexpr bool found[size] = { Condition<T, Ts>::value ... };
+  constexpr bool found[size] = {Condition<T, Ts>::value...};
   for (size_t i = 0; i < size; ++i) {
     if (found[i]) {
       return i;

Framework/Foundation/include/Framework/Traits.h

@@ -33,7 +33,9 @@ inline constexpr bool is_specialization_v = is_specialization<T, Ref>::value;
 
 template <template <typename...> typename B, typename S>
 concept specialization = requires {
-  {[]<typename... Ts>(B<Ts...>*) -> B<Ts...> {}(std::declval<S*>())} -> std::same_as<S>;
+  {
+    []<typename... Ts>(B<Ts...>*) -> B<Ts...> {}(std::declval<S*>())
+  } -> std::same_as<S>;
 };
 
 template <typename A, typename B>
@@ -63,7 +65,7 @@ inline constexpr bool always_static_assert_v = always_static_assert<T...>::value
 
 template <template <typename...> typename B, typename D>
 concept base_of_template = requires {
-  []<typename... Ts>(B<Ts...>*){ }(std::declval<D*>());
+  []<typename... Ts>(B<Ts...>*) {}(std::declval<D*>());
 };
 
 template <template <typename...> typename B, typename D>