Change clang-format to v18 to match the CI clang version and update format

zanmato1984 · zanmato1984 · commit 444462675a8a · 2026-01-10T23:17:48.000+08:00
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -50,7 +50,7 @@ repos:
           )
         types: []
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v20.1.8
+    rev: v18.1.8
     hooks:
       - id: clang-format
         # Fixing pre-commit provided by CI Ubuntu 22
@@ -95,7 +95,7 @@ repos:
           ?^cpp/thirdparty/|
           )
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v20.1.8
+    rev: v18.1.8
     hooks:
       - id: clang-format
         # Fixing pre-commit provided by CI Ubuntu 22
@@ -105,7 +105,7 @@ repos:
         files: >-
           ^c_glib/
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v20.1.8
+    rev: v18.1.8
     hooks:
       - id: clang-format
         # Fixing pre-commit provided by CI Ubuntu 22
@@ -162,7 +162,7 @@ repos:
         files: >-
           ^python/
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v20.1.8
+    rev: v18.1.8
     hooks:
       - id: clang-format
         # Fixing pre-commit provided by CI Ubuntu 22
@@ -221,7 +221,7 @@ repos:
         files: >-
             ^r/.*\.R$
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v20.1.8
+    rev: v18.1.8
     hooks:
       - id: clang-format
         # Fixing pre-commit provided by CI Ubuntu 22
diff --git a/cpp/src/arrow/acero/exec_plan.cc b/cpp/src/arrow/acero/exec_plan.cc
@@ -137,7 +137,7 @@ struct ExecPlanImpl : public ExecPlan {
             opentelemetry::nostd::shared_ptr<opentelemetry::trace::Span> span =
                 ::arrow::internal::tracing::UnwrapSpan(span_.details.get());
             std::for_each(std::begin(pairs), std::end(pairs),
-                          [span](std::pair<std::string, std::string> const& pair) {
+                          [span](const std::pair<std::string, std::string>& pair) {
                             span->SetAttribute(pair.first, pair.second);
                           });
           }
diff --git a/cpp/src/arrow/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
@@ -533,7 +533,7 @@ namespace {
 struct ExportedArrayPrivateData : PoolAllocationMixin<ExportedArrayPrivateData> {
   // The buffers are owned by the ArrayData member
   SmallVector<const void*, 3> buffers_;
-  struct ArrowArray dictionary_{};
+  struct ArrowArray dictionary_ {};
   SmallVector<struct ArrowArray, 1> children_;
   SmallVector<struct ArrowArray*, 4> child_pointers_;
 
diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
@@ -1226,8 +1226,8 @@ TEST_F(TestArrayExport, MoveSeveralChildren) {
 }
 
 TEST_F(TestArrayExport, ExportArrayAndType) {
-  struct ArrowSchema c_schema{};
-  struct ArrowArray c_array{};
+  struct ArrowSchema c_schema {};
+  struct ArrowArray c_array {};
   SchemaExportGuard schema_guard(&c_schema);
   ArrayExportGuard array_guard(&c_array);
 
@@ -1244,8 +1244,8 @@ TEST_F(TestArrayExport, ExportArrayAndType) {
 }
 
 TEST_F(TestArrayExport, ExportRecordBatch) {
-  struct ArrowSchema c_schema{};
-  struct ArrowArray c_array{};
+  struct ArrowSchema c_schema {};
+  struct ArrowArray c_array {};
 
   auto schema = ::arrow::schema(
       {field("ints", int16()), field("bools", boolean(), /*nullable=*/false)});
@@ -1704,8 +1704,8 @@ TEST_F(TestDeviceArrayExport, ExportArrayAndType) {
   std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
   auto mm = device->default_memory_manager();
 
-  struct ArrowSchema c_schema{};
-  struct ArrowDeviceArray c_array{};
+  struct ArrowSchema c_schema {};
+  struct ArrowDeviceArray c_array {};
   SchemaExportGuard schema_guard(&c_schema);
   ArrayExportGuard array_guard(&c_array.array);
 
@@ -1726,8 +1726,8 @@ TEST_F(TestDeviceArrayExport, ExportRecordBatch) {
   std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
   auto mm = device->default_memory_manager();
 
-  struct ArrowSchema c_schema{};
-  struct ArrowDeviceArray c_array{};
+  struct ArrowSchema c_schema {};
+  struct ArrowDeviceArray c_array {};
 
   auto schema = ::arrow::schema(
       {field("ints", int16()), field("bools", boolean(), /*nullable=*/false)});
@@ -3619,7 +3619,7 @@ class TestSchemaRoundtrip : public ::testing::Test {
   void TestWithTypeFactory(TypeFactory&& factory,
                            ExpectedTypeFactory&& factory_expected) {
     std::shared_ptr<DataType> type, actual;
-    struct ArrowSchema c_schema{};  // zeroed
+    struct ArrowSchema c_schema {};  // zeroed
     SchemaExportGuard schema_guard(&c_schema);
 
     auto orig_bytes = pool_->bytes_allocated();
@@ -3650,7 +3650,7 @@ class TestSchemaRoundtrip : public ::testing::Test {
   template <typename SchemaFactory>
   void TestWithSchemaFactory(SchemaFactory&& factory) {
     std::shared_ptr<Schema> schema, actual;
-    struct ArrowSchema c_schema{};  // zeroed
+    struct ArrowSchema c_schema {};  // zeroed
     SchemaExportGuard schema_guard(&c_schema);
 
     auto orig_bytes = pool_->bytes_allocated();
@@ -3865,8 +3865,8 @@ class TestArrayRoundtrip : public ::testing::Test {
   void TestWithArrayFactory(ArrayFactory&& factory,
                             ExpectedArrayFactory&& factory_expected) {
     std::shared_ptr<Array> array;
-    struct ArrowArray c_array{};
-    struct ArrowSchema c_schema{};
+    struct ArrowArray c_array {};
+    struct ArrowSchema c_schema {};
     ArrayExportGuard array_guard(&c_array);
     SchemaExportGuard schema_guard(&c_schema);
 
@@ -3910,8 +3910,8 @@ class TestArrayRoundtrip : public ::testing::Test {
   template <typename BatchFactory>
   void TestWithBatchFactory(BatchFactory&& factory) {
     std::shared_ptr<RecordBatch> batch;
-    struct ArrowArray c_array{};
-    struct ArrowSchema c_schema{};
+    struct ArrowArray c_array {};
+    struct ArrowSchema c_schema {};
     ArrayExportGuard array_guard(&c_array);
     SchemaExportGuard schema_guard(&c_schema);
 
@@ -4184,7 +4184,7 @@ TEST_F(TestArrayRoundtrip, RegisteredExtensionNoMetadata) {
       KeyValueMetadata::Make({"ARROW:extension:name"}, {ext_type->extension_name()});
   auto ext_field = field("", ext_type->storage_type(), true, std::move(ext_metadata));
 
-  struct ArrowSchema c_schema{};
+  struct ArrowSchema c_schema {};
   SchemaExportGuard schema_guard(&c_schema);
   ASSERT_OK(ExportField(*ext_field, &c_schema));
 
@@ -4305,8 +4305,8 @@ class TestDeviceArrayRoundtrip : public ::testing::Test {
   void TestWithArrayFactory(ArrayFactory&& factory,
                             ExpectedArrayFactory&& factory_expected) {
     std::shared_ptr<Array> array;
-    struct ArrowDeviceArray c_array{};
-    struct ArrowSchema c_schema{};
+    struct ArrowDeviceArray c_array {};
+    struct ArrowSchema c_schema {};
     ArrayExportGuard array_guard(&c_array.array);
     SchemaExportGuard schema_guard(&c_schema);
 
@@ -4354,8 +4354,8 @@ class TestDeviceArrayRoundtrip : public ::testing::Test {
     auto mm = device->default_memory_manager();
 
     std::shared_ptr<RecordBatch> batch;
-    struct ArrowDeviceArray c_array{};
-    struct ArrowSchema c_schema{};
+    struct ArrowDeviceArray c_array {};
+    struct ArrowSchema c_schema {};
     ArrayExportGuard array_guard(&c_array.array);
     SchemaExportGuard schema_guard(&c_schema);
 
diff --git a/cpp/src/arrow/compute/kernels/hash_aggregate.cc b/cpp/src/arrow/compute/kernels/hash_aggregate.cc
@@ -282,7 +282,7 @@ concept CFloatingPointConcept = std::floating_point<T> || std::same_as<T, util::
 
 template <typename T>
 concept CDecimalConcept = std::same_as<T, Decimal32> || std::same_as<T, Decimal64> ||
-    std::same_as<T, Decimal128> || std::same_as<T, Decimal256>;
+                          std::same_as<T, Decimal128> || std::same_as<T, Decimal256>;
 
 template <typename CType>
 struct AntiExtrema {
diff --git a/cpp/src/arrow/compute/kernels/scalar_round.cc b/cpp/src/arrow/compute/kernels/scalar_round.cc
@@ -1227,10 +1227,11 @@ Status FixedRoundDecimalExec(KernelContext* ctx, const ExecSpan& batch, ExecResu
 // ----------------------------------------------------------------------
 // Begin round kernel generation and function registration
 
-template <template <typename, RoundMode, typename...> class Op,
-          template <typename, typename,
-                    template <typename, RoundMode, typename...> typename> class Kernel,
-          typename OptionsType>
+template <
+    template <typename, RoundMode, typename...> class Op,
+    template <typename, typename, template <typename, RoundMode, typename...> typename>
+    class Kernel,
+    typename OptionsType>
 struct RoundKernelGenerator {
   template <typename ArrowType>
   Status Visit(const ArrowType& type, ArrayKernelExec* exec, KernelInit* init) {
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_binary.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_binary.cc
@@ -313,11 +313,11 @@ using NanosecondsBetween = UnitsBetween<std::chrono::nanoseconds, Duration, Loca
 // ----------------------------------------------------------------------
 // Registration helpers
 
-template <
-    template <typename...> class Op,
-    template <template <typename...> class OpExec, typename Duration, typename InType,
-              typename OutType, typename... Args> class ExecTemplate,
-    typename OutType>
+template <template <typename...> class Op,
+          template <template <typename...> class OpExec, typename Duration,
+                    typename InType, typename OutType, typename... Args>
+          class ExecTemplate,
+          typename OutType>
 struct BinaryTemporalFactory {
   OutputType out_type;
   KernelInit init;
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_unary.cc
@@ -1533,11 +1533,11 @@ struct ISOCalendar {
 // ----------------------------------------------------------------------
 // Registration helpers
 
-template <
-    template <typename...> class Op,
-    template <template <typename...> class OpExec, typename Duration, typename InType,
-              typename OutType, typename... Args> class ExecTemplate,
-    typename OutType>
+template <template <typename...> class Op,
+          template <template <typename...> class OpExec, typename Duration,
+                    typename InType, typename OutType, typename... Args>
+          class ExecTemplate,
+          typename OutType>
 struct UnaryTemporalFactory {
   OutputType out_type;
   KernelInit init;
diff --git a/cpp/src/arrow/compute/kernels/temporal_internal.h b/cpp/src/arrow/compute/kernels/temporal_internal.h
@@ -45,8 +45,8 @@ using std::chrono::duration_cast;
 using ArrowTimeZone = std::variant<const time_zone*, OffsetZone>;
 
 template <class Duration, class Func>
-auto ApplyTimeZone(const ArrowTimeZone& tz, sys_time<Duration> st, Func&& func)
-    -> decltype(func(zoned_time<Duration>{})) {
+auto ApplyTimeZone(const ArrowTimeZone& tz, sys_time<Duration> st,
+                   Func&& func) -> decltype(func(zoned_time<Duration>{})) {
   return std::visit(
       [&](auto&& zone) {
         if constexpr (std::is_pointer_v<std::decay_t<decltype(zone)> >) {
@@ -60,8 +60,8 @@ auto ApplyTimeZone(const ArrowTimeZone& tz, sys_time<Duration> st, Func&& func)
 
 template <class Duration, class Func>
 auto ApplyTimeZone(const ArrowTimeZone& tz, local_time<Duration> lt,
-                   std::optional<choose> c, Func&& func)
-    -> decltype(func(zoned_time<Duration>{})) {
+                   std::optional<choose> c,
+                   Func&& func) -> decltype(func(zoned_time<Duration>{})) {
   return std::visit(
       [&](auto&& zone) {
         if constexpr (std::is_pointer_v<std::decay_t<decltype(zone)> >) {
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_test.cc b/cpp/src/arrow/compute/kernels/vector_sort_test.cc
@@ -76,8 +76,8 @@ std::ostream& operator<<(std::ostream& os, NullPlacement null_placement) {
 // Tests for NthToIndices
 
 template <typename ArrayType>
-auto GetLogicalValue(const ArrayType& array, uint64_t index)
-    -> decltype(array.GetView(index)) {
+auto GetLogicalValue(const ArrayType& array,
+                     uint64_t index) -> decltype(array.GetView(index)) {
   return array.GetView(index);
 }
 
diff --git a/cpp/src/arrow/dataset/scanner.cc b/cpp/src/arrow/dataset/scanner.cc
@@ -753,7 +753,7 @@ Future<int64_t> AsyncScanner::CountRowsAsync(Executor* executor) {
       [options, total](const std::shared_ptr<Fragment>& fragment) {
         return fragment->CountRows(options->filter, options)
             .Then([options, total, fragment](std::optional<int64_t> fast_count) mutable
-                      -> std::shared_ptr<Fragment> {
+                  -> std::shared_ptr<Fragment> {
               if (fast_count) {
                 // fast path: got row count directly; skip scanning this fragment
                 (*total) += *fast_count;
diff --git a/cpp/src/arrow/device.cc b/cpp/src/arrow/device.cc
@@ -42,8 +42,7 @@ Result<std::shared_ptr<Device::SyncEvent>> MemoryManager::WrapDeviceSyncEvent(
   return nullptr;
 }
 
-Device::~Device() {}
-
+Device::~Device(){}
 #define COPY_BUFFER_SUCCESS(maybe_buffer) \
   ((maybe_buffer).ok() && *(maybe_buffer) != nullptr)
 
diff --git a/cpp/src/arrow/gpu/cuda_test.cc b/cpp/src/arrow/gpu/cuda_test.cc
@@ -785,8 +785,8 @@ class TestCudaDeviceArrayRoundtrip : public ::testing::Test {
     ASSERT_OK_AND_ASSIGN(array, factory());
     ASSERT_OK_AND_ASSIGN(device_array, array->CopyTo(mm));
 
-    struct ArrowDeviceArray c_array{};
-    struct ArrowSchema c_schema{};
+    struct ArrowDeviceArray c_array {};
+    struct ArrowSchema c_schema {};
     ArrayExportGuard array_guard(&c_array.array);
     SchemaExportGuard schema_guard(&c_schema);
 
diff --git a/cpp/src/arrow/scalar.cc b/cpp/src/arrow/scalar.cc
@@ -565,7 +565,7 @@ struct ScalarValidateImpl {
 };
 
 template <typename T, size_t N>
-void FillScalarScratchSpace(void* scratch_space, T const (&arr)[N]) {
+void FillScalarScratchSpace(void* scratch_space, const T (&arr)[N]) {
   static_assert(sizeof(arr) <= internal::kScalarScratchSpaceSize);
   std::memcpy(scratch_space, arr, sizeof(arr));
 }
diff --git a/cpp/src/arrow/util/bit_util_benchmark.cc b/cpp/src/arrow/util/bit_util_benchmark.cc
@@ -541,7 +541,10 @@ BENCHMARK(CopyBitmapWithOffsetBoth)->Arg(kBufferSize);
 BENCHMARK(BitmapEqualsWithoutOffset)->Arg(kBufferSize);
 BENCHMARK(BitmapEqualsWithOffset)->Arg(kBufferSize);
 
-#define AND_BENCHMARK_RANGES {{kBufferSize * 4, kBufferSize * 16}, {0, 2}}
+#define AND_BENCHMARK_RANGES                      \
+  {                                               \
+    {kBufferSize * 4, kBufferSize * 16}, { 0, 2 } \
+  }
 BENCHMARK(BenchmarkBitmapAnd)->Ranges(AND_BENCHMARK_RANGES);
 BENCHMARK(BenchmarkBitmapVisitBitsetAnd)->Ranges(AND_BENCHMARK_RANGES);
 BENCHMARK(BenchmarkBitmapVisitUInt8And)->Ranges(AND_BENCHMARK_RANGES);
diff --git a/cpp/src/arrow/util/bpacking.cc b/cpp/src/arrow/util/bpacking.cc
@@ -33,15 +33,15 @@ struct UnpackDynamicFunction {
   using Implementation = std::pair<DispatchLevel, FunctionType>;
 
   static constexpr auto implementations() {
-    return std::array {
-      // Current SIMD unpack algorithm works terribly on SSE4.2 due to lack of variable
-      // rhsift and poor xsimd fallback.
-      Implementation{DispatchLevel::NONE, &unpack_scalar<Uint>},
+    return std::array{
+        // Current SIMD unpack algorithm works terribly on SSE4.2 due to lack of variable
+        // rhsift and poor xsimd fallback.
+        Implementation{DispatchLevel::NONE, &unpack_scalar<Uint>},
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
-          Implementation{DispatchLevel::AVX2, &unpack_avx2<Uint>},
+        Implementation{DispatchLevel::AVX2, &unpack_avx2<Uint>},
 #endif
 #if defined(ARROW_HAVE_RUNTIME_AVX512)
-          Implementation{DispatchLevel::AVX512, &unpack_avx512<Uint>},
+        Implementation{DispatchLevel::AVX512, &unpack_avx512<Uint>},
 #endif
     };
   }
diff --git a/cpp/src/arrow/util/byte_stream_split_internal.h b/cpp/src/arrow/util/byte_stream_split_internal.h
@@ -122,8 +122,8 @@ void ByteStreamSplitDecodeSimd(const uint8_t* data, int width, int64_t num_value
 
 // Like xsimd::zip_lo, but zip groups of kNumBytes at once.
 template <typename Arch, int kNumBytes>
-auto zip_lo_n(const xsimd::batch<int8_t, Arch>& a, const xsimd::batch<int8_t, Arch>& b)
-    -> xsimd::batch<int8_t, Arch> {
+auto zip_lo_n(const xsimd::batch<int8_t, Arch>& a,
+              const xsimd::batch<int8_t, Arch>& b) -> xsimd::batch<int8_t, Arch> {
   using arrow::internal::SizedInt;
   using simd_batch = xsimd::batch<int8_t, Arch>;
   // For signed arithmetic
@@ -146,8 +146,8 @@ auto zip_lo_n(const xsimd::batch<int8_t, Arch>& a, const xsimd::batch<int8_t, Ar
 
 // Like xsimd::zip_hi, but zip groups of kNumBytes at once.
 template <typename Arch, int kNumBytes>
-auto zip_hi_n(const xsimd::batch<int8_t, Arch>& a, const xsimd::batch<int8_t, Arch>& b)
-    -> xsimd::batch<int8_t, Arch> {
+auto zip_hi_n(const xsimd::batch<int8_t, Arch>& a,
+              const xsimd::batch<int8_t, Arch>& b) -> xsimd::batch<int8_t, Arch> {
   using simd_batch = xsimd::batch<int8_t, Arch>;
   using arrow::internal::SizedInt;
   // For signed arithmetic
diff --git a/cpp/src/arrow/util/compare.h b/cpp/src/arrow/util/compare.h
@@ -51,8 +51,8 @@ class EqualityComparable {
     }
   };
 
-  friend bool operator==(T const& a, T const& b) { return a.Equals(b); }
-  friend bool operator!=(T const& a, T const& b) { return !(a == b); }
+  friend bool operator==(const T& a, const T& b) { return a.Equals(b); }
+  friend bool operator!=(const T& a, const T& b) { return !(a == b); }
 
  private:
   const T& cast() const { return static_cast<const T&>(*this); }
diff --git a/cpp/src/arrow/util/hash_util.h b/cpp/src/arrow/util/hash_util.h
@@ -54,7 +54,7 @@ inline void hash_combine_impl(uint32_t& h1, uint32_t k1) {
 }  // namespace detail
 
 template <class T>
-inline void hash_combine(std::size_t& seed, T const& v) {
+inline void hash_combine(std::size_t& seed, const T& v) {
   std::hash<T> hasher;
   return ::arrow::internal::detail::hash_combine_impl(seed, hasher(v));
 }
diff --git a/cpp/src/arrow/util/reflection_internal.h b/cpp/src/arrow/util/reflection_internal.h
diff --git a/cpp/src/arrow/util/rle_encoding_internal.h b/cpp/src/arrow/util/rle_encoding_internal.h
diff --git a/cpp/src/arrow/util/span.h b/cpp/src/arrow/util/span.h
diff --git a/cpp/src/arrow/util/thread_pool.cc b/cpp/src/arrow/util/thread_pool.cc
diff --git a/cpp/src/gandiva/gdv_string_function_stubs.cc b/cpp/src/gandiva/gdv_string_function_stubs.cc
diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
diff --git a/cpp/src/parquet/types.cc b/cpp/src/parquet/types.cc

Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ struct ExecPlanImpl : public ExecPlan {`
`137`	`137`	`opentelemetry::nostd::shared_ptr<opentelemetry::trace::Span> span =`
`138`	`138`	`::arrow::internal::tracing::UnwrapSpan(span_.details.get());`
`139`	`139`	`std::for_each(std::begin(pairs), std::end(pairs),`
`140`		`- [span](std::pair<std::string, std::string> const& pair) {`
	`140`	`+ [span](const std::pair<std::string, std::string>& pair) {`
`141`	`141`	`span->SetAttribute(pair.first, pair.second);`
`142`	`142`	`});`
`143`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,8 +76,8 @@ std::ostream& operator<<(std::ostream& os, NullPlacement null_placement) {`
`76`	`76`	`// Tests for NthToIndices`
`77`	`77`
`78`	`78`	`template <typename ArrayType>`
`79`		`-auto GetLogicalValue(const ArrayType& array, uint64_t index)`
`80`		`- -> decltype(array.GetView(index)) {`
	`79`	`+auto GetLogicalValue(const ArrayType& array,`
	`80`	`+ uint64_t index) -> decltype(array.GetView(index)) {`
`81`	`81`	`return array.GetView(index);`
`82`	`82`	`}`
`83`	`83`