From 728169c259d8e4c5fbedae176acdc6f450715ecb Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 15 Aug 2024 14:38:19 -0300
Subject: [PATCH 01/16] Rename aggregate_basic_internal.h to
 aggregate_basic_internal.inc.cc

---
 cpp/src/arrow/compute/kernels/aggregate_basic.cc                | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc           | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc         | 2 +-
 ...gregate_basic_internal.h => aggregate_basic_internal.inc.cc} | 0
 4 files changed, 3 insertions(+), 3 deletions(-)
 rename cpp/src/arrow/compute/kernels/{aggregate_basic_internal.h => aggregate_basic_internal.inc.cc} (100%)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index c5e0e6fd6e9..831d211670c 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -16,7 +16,7 @@
 // under the License.
 
 #include "arrow/compute/api_aggregate.h"
-#include "arrow/compute/kernels/aggregate_basic_internal.h"
+#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"  // XXX: fix
 #include "arrow/compute/kernels/aggregate_internal.h"
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/compute/kernels/util_internal.h"
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index 03b45107eec..50c72dc1a96 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/compute/kernels/aggregate_basic_internal.h"
+#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"  // XXX: fix
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 05356e0aa5e..09711c02405 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/compute/kernels/aggregate_basic_internal.h"
+#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"  // XXX: fix
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc
similarity index 100%
rename from cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
rename to cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc

From 233fa480937a1a95cb15e878ca602cec00a2e6ad Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 15 Aug 2024 15:38:21 -0300
Subject: [PATCH 02/16] Use aggregate_basic_internal.inc.cc from specific
 compilation units

---
 .../arrow/compute/kernels/aggregate_basic.cc  | 17 +++++-
 .../compute/kernels/aggregate_basic_avx2.cc   | 20 +++++++
 .../compute/kernels/aggregate_basic_avx512.cc | 22 +++++++-
 .../kernels/aggregate_basic_internal.h        | 52 +++++++++++++++++++
 .../kernels/aggregate_basic_internal.inc.cc   | 46 +++-------------
 5 files changed, 116 insertions(+), 41 deletions(-)
 create mode 100644 cpp/src/arrow/compute/kernels/aggregate_basic_internal.h

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 831d211670c..1bd19ab8e7a 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -15,15 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cmath>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
 #include "arrow/compute/api_aggregate.h"
-#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"  // XXX: fix
+#include "arrow/compute/kernels/aggregate_basic_internal.h"
 #include "arrow/compute/kernels/aggregate_internal.h"
+#include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/compute/kernels/util_internal.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/align_util.h"
+#include "arrow/util/bit_block_counter.h"
 #include "arrow/util/cpu_info.h"
+#include "arrow/util/decimal.h"
 #include "arrow/util/hashing.h"
 
-#include <memory>
+// Include templated definitions for aggregate kernels that must compiled here
+// with the SIMD level configured for this compilation unit in the build.
+#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index 50c72dc1a96..33c89a4182f 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -15,6 +15,26 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cmath>
+#include <type_traits>
+#include <utility>
+
+#include "arrow/compute/api_aggregate.h"
+#include "arrow/compute/kernels/aggregate_basic_internal.h"
+#include "arrow/compute/kernels/aggregate_internal.h"
+#include "arrow/compute/kernels/codegen_internal.h"
+#include "arrow/compute/kernels/common_internal.h"
+#include "arrow/compute/kernels/util_internal.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/align_util.h"
+#include "arrow/util/bit_block_counter.h"
+#include "arrow/util/cpu_info.h"
+#include "arrow/util/decimal.h"
+#include "arrow/util/hashing.h"
+
+// Include templated definitions for aggregate kernels that must compiled here
+// with the SIMD level configured for this compilation unit in the build.
 #include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"  // XXX: fix
 
 namespace arrow {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 09711c02405..9d598a2135e 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -15,7 +15,27 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"  // XXX: fix
+#include <cmath>
+#include <type_traits>
+#include <utility>
+
+#include "arrow/compute/api_aggregate.h"
+#include "arrow/compute/kernels/aggregate_basic_internal.h"
+#include "arrow/compute/kernels/aggregate_internal.h"
+#include "arrow/compute/kernels/codegen_internal.h"
+#include "arrow/compute/kernels/common_internal.h"
+#include "arrow/compute/kernels/util_internal.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/align_util.h"
+#include "arrow/util/bit_block_counter.h"
+#include "arrow/util/cpu_info.h"
+#include "arrow/util/decimal.h"
+#include "arrow/util/hashing.h"
+
+// Include templated definitions for aggregate kernels that must compiled here
+// with the SIMD level configured for this compilation unit in the build.
+#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
new file mode 100644
index 00000000000..f111e56f1d8
--- /dev/null
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -0,0 +1,52 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "arrow/compute/kernel.h"
+#include "arrow/compute/kernels/codegen_internal.h"
+#include "arrow/compute/type_fwd.h"
+#include "arrow/type_fwd.h"
+
+namespace arrow::compute::internal {
+
+void AddBasicAggKernels(KernelInit init,
+                        const std::vector<std::shared_ptr<DataType>>& types,
+                        std::shared_ptr<DataType> out_ty, ScalarAggregateFunction* func,
+                        SimdLevel::type simd_level = SimdLevel::NONE);
+
+void AddMinMaxKernels(KernelInit init,
+                      const std::vector<std::shared_ptr<DataType>>& types,
+                      ScalarAggregateFunction* func,
+                      SimdLevel::type simd_level = SimdLevel::NONE);
+void AddMinMaxKernel(KernelInit init, internal::detail::GetTypeId get_id,
+                     ScalarAggregateFunction* func,
+                     SimdLevel::type simd_level = SimdLevel::NONE);
+
+// SIMD variants for kernels
+void AddSumAvx2AggKernels(ScalarAggregateFunction* func);
+void AddMeanAvx2AggKernels(ScalarAggregateFunction* func);
+void AddMinMaxAvx2AggKernels(ScalarAggregateFunction* func);
+
+void AddSumAvx512AggKernels(ScalarAggregateFunction* func);
+void AddMeanAvx512AggKernels(ScalarAggregateFunction* func);
+void AddMinMaxAvx512AggKernels(ScalarAggregateFunction* func);
+
+}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc
index f08e7aaa538..cbe0bb72fde 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc
@@ -15,46 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#pragma once
-
-#include <cmath>
-#include <type_traits>
-#include <utility>
-
-#include "arrow/compute/api_aggregate.h"
-#include "arrow/compute/kernels/aggregate_internal.h"
-#include "arrow/compute/kernels/codegen_internal.h"
-#include "arrow/compute/kernels/common_internal.h"
-#include "arrow/compute/kernels/util_internal.h"
-#include "arrow/type.h"
-#include "arrow/type_traits.h"
-#include "arrow/util/align_util.h"
-#include "arrow/util/bit_block_counter.h"
-#include "arrow/util/decimal.h"
+// .inc.cc file to be included in compilation unit where kernels are meant to
+// be compiled auto-vectorized by the compiler with different SIMD levels passed
+// as compiler flags.
+//
+// It contains no includes to avoid double inclusion in the compilation unit
+// that includes this .inc.cc file.
 
 namespace arrow::compute::internal {
-
-void AddBasicAggKernels(KernelInit init,
-                        const std::vector<std::shared_ptr<DataType>>& types,
-                        std::shared_ptr<DataType> out_ty, ScalarAggregateFunction* func,
-                        SimdLevel::type simd_level = SimdLevel::NONE);
-
-void AddMinMaxKernels(KernelInit init,
-                      const std::vector<std::shared_ptr<DataType>>& types,
-                      ScalarAggregateFunction* func,
-                      SimdLevel::type simd_level = SimdLevel::NONE);
-void AddMinMaxKernel(KernelInit init, internal::detail::GetTypeId get_id,
-                     ScalarAggregateFunction* func,
-                     SimdLevel::type simd_level = SimdLevel::NONE);
-
-// SIMD variants for kernels
-void AddSumAvx2AggKernels(ScalarAggregateFunction* func);
-void AddMeanAvx2AggKernels(ScalarAggregateFunction* func);
-void AddMinMaxAvx2AggKernels(ScalarAggregateFunction* func);
-
-void AddSumAvx512AggKernels(ScalarAggregateFunction* func);
-void AddMeanAvx512AggKernels(ScalarAggregateFunction* func);
-void AddMinMaxAvx512AggKernels(ScalarAggregateFunction* func);
+namespace {
 
 // ----------------------------------------------------------------------
 // Sum implementation
@@ -1033,4 +1002,5 @@ struct MinMaxInitState {
   }
 };
 
+}  // namespace
 }  // namespace arrow::compute::internal

From 79b01d55dd49c3988e752298bf1d2566a807a0fa Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 15 Aug 2024 18:25:40 -0300
Subject: [PATCH 03/16] Rename aggregate_basic_internal.inc.cc to
 aggregate_basic-inl.h

---
 ...ggregate_basic_internal.inc.cc => aggregate_basic-inl.h} | 6 +++---
 cpp/src/arrow/compute/kernels/aggregate_basic.cc            | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc       | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc     | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)
 rename cpp/src/arrow/compute/kernels/{aggregate_basic_internal.inc.cc => aggregate_basic-inl.h} (99%)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
similarity index 99%
rename from cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc
rename to cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
index cbe0bb72fde..7eaaf7836ff 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.inc.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
@@ -15,12 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// .inc.cc file to be included in compilation unit where kernels are meant to
-// be compiled auto-vectorized by the compiler with different SIMD levels passed
+// -inl.h file to be included in compilation unit where kernels are meant to be
+// compiled auto-vectorized by the compiler with different SIMD levels passed
 // as compiler flags.
 //
 // It contains no includes to avoid double inclusion in the compilation unit
-// that includes this .inc.cc file.
+// that includes this -inl.h file.
 
 namespace arrow::compute::internal {
 namespace {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 1bd19ab8e7a..1358b0341ed 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -36,7 +36,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"
+#include "arrow/compute/kernels/aggregate_basic-inl.h"
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index 33c89a4182f..a597b0a0cf9 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -35,7 +35,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"  // XXX: fix
+#include "arrow/compute/kernels/aggregate_basic-inl.h"
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 9d598a2135e..544a2091e37 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -35,7 +35,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic_internal.inc.cc"
+#include "arrow/compute/kernels/aggregate_basic-inl.h"
 
 namespace arrow {
 namespace compute {

From 5fb32ce2f4bc16aa816d6edb6dc8972218fb749d Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 15 Aug 2024 19:51:28 -0300
Subject: [PATCH 04/16] Organize the kernels

---
 .../compute/kernels/aggregate_basic-inl.h     | 215 +++++++++---------
 .../arrow/compute/kernels/aggregate_basic.cc  |  33 +--
 .../compute/kernels/aggregate_basic_avx2.cc   |  33 +--
 .../compute/kernels/aggregate_basic_avx512.cc |  37 +--
 .../kernels/aggregate_basic_internal.h        |   7 +-
 5 files changed, 171 insertions(+), 154 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
index 7eaaf7836ff..37ab9a9e611 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
@@ -140,6 +140,56 @@ struct NullSumImpl : public NullImpl<ArrowType> {
   }
 };
 
+template <template <typename> class KernelClass>
+struct SumLikeInit {
+  std::unique_ptr<KernelState> state;
+  KernelContext* ctx;
+  std::shared_ptr<DataType> type;
+  const ScalarAggregateOptions& options;
+
+  SumLikeInit(KernelContext* ctx, std::shared_ptr<DataType> type,
+              const ScalarAggregateOptions& options)
+      : ctx(ctx), type(type), options(options) {}
+
+  Status Visit(const DataType&) { return Status::NotImplemented("No sum implemented"); }
+
+  Status Visit(const HalfFloatType&) {
+    return Status::NotImplemented("No sum implemented");
+  }
+
+  Status Visit(const BooleanType&) {
+    auto ty = TypeTraits<typename KernelClass<BooleanType>::SumType>::type_singleton();
+    state.reset(new KernelClass<BooleanType>(ty, options));
+    return Status::OK();
+  }
+
+  template <typename Type>
+  enable_if_number<Type, Status> Visit(const Type&) {
+    auto ty = TypeTraits<typename KernelClass<Type>::SumType>::type_singleton();
+    state.reset(new KernelClass<Type>(ty, options));
+    return Status::OK();
+  }
+
+  template <typename Type>
+  enable_if_decimal<Type, Status> Visit(const Type&) {
+    state.reset(new KernelClass<Type>(type, options));
+    return Status::OK();
+  }
+
+  virtual Status Visit(const NullType&) {
+    state.reset(new NullSumImpl<Int64Type>(options));
+    return Status::OK();
+  }
+
+  Result<std::unique_ptr<KernelState>> Create() {
+    RETURN_NOT_OK(VisitTypeInline(*type, this));
+    return std::move(state);
+  }
+};
+
+// ----------------------------------------------------------------------
+// Mean implementation
+
 template <typename ArrowType, SimdLevel::type SimdLevel, typename Enable = void>
 struct MeanImpl;
 
@@ -202,53 +252,6 @@ struct MeanImpl<ArrowType, SimdLevel,
   Status Finalize(KernelContext*, Datum* out) override { return FinalizeImpl(out); }
 };
 
-template <template <typename> class KernelClass>
-struct SumLikeInit {
-  std::unique_ptr<KernelState> state;
-  KernelContext* ctx;
-  std::shared_ptr<DataType> type;
-  const ScalarAggregateOptions& options;
-
-  SumLikeInit(KernelContext* ctx, std::shared_ptr<DataType> type,
-              const ScalarAggregateOptions& options)
-      : ctx(ctx), type(type), options(options) {}
-
-  Status Visit(const DataType&) { return Status::NotImplemented("No sum implemented"); }
-
-  Status Visit(const HalfFloatType&) {
-    return Status::NotImplemented("No sum implemented");
-  }
-
-  Status Visit(const BooleanType&) {
-    auto ty = TypeTraits<typename KernelClass<BooleanType>::SumType>::type_singleton();
-    state.reset(new KernelClass<BooleanType>(ty, options));
-    return Status::OK();
-  }
-
-  template <typename Type>
-  enable_if_number<Type, Status> Visit(const Type&) {
-    auto ty = TypeTraits<typename KernelClass<Type>::SumType>::type_singleton();
-    state.reset(new KernelClass<Type>(ty, options));
-    return Status::OK();
-  }
-
-  template <typename Type>
-  enable_if_decimal<Type, Status> Visit(const Type&) {
-    state.reset(new KernelClass<Type>(type, options));
-    return Status::OK();
-  }
-
-  virtual Status Visit(const NullType&) {
-    state.reset(new NullSumImpl<Int64Type>(options));
-    return Status::OK();
-  }
-
-  Result<std::unique_ptr<KernelState>> Create() {
-    RETURN_NOT_OK(VisitTypeInline(*type, this));
-    return std::move(state);
-  }
-};
-
 template <template <typename> class KernelClass>
 struct MeanKernelInit : public SumLikeInit<KernelClass> {
   MeanKernelInit(KernelContext* ctx, std::shared_ptr<DataType> type,
@@ -263,6 +266,7 @@ struct MeanKernelInit : public SumLikeInit<KernelClass> {
 
 // ----------------------------------------------------------------------
 // FirstLast implementation
+
 template <typename ArrowType, typename Enable = void>
 struct FirstLastState {};
 
@@ -529,8 +533,66 @@ struct FirstLastImpl : public ScalarAggregator {
   FirstLastState<ArrowType> state;
 };
 
+struct FirstLastInitState {
+  std::unique_ptr<KernelState> state;
+  KernelContext* ctx;
+  const DataType& in_type;
+  std::shared_ptr<DataType> out_type;
+  const ScalarAggregateOptions& options;
+
+  FirstLastInitState(KernelContext* ctx, const DataType& in_type,
+                     const std::shared_ptr<DataType>& out_type,
+                     const ScalarAggregateOptions& options)
+      : ctx(ctx), in_type(in_type), out_type(out_type), options(options) {}
+
+  Status Visit(const DataType& ty) {
+    return Status::NotImplemented("No first/last implemented for ", ty);
+  }
+
+  Status Visit(const HalfFloatType& ty) {
+    return Status::NotImplemented("No first/last implemented for ", ty);
+  }
+
+  Status Visit(const BooleanType&) {
+    state.reset(new FirstLastImpl<BooleanType>(out_type, options));
+    return Status::OK();
+  }
+
+  template <typename Type>
+  enable_if_physical_integer<Type, Status> Visit(const Type&) {
+    using PhysicalType = typename Type::PhysicalType;
+    state.reset(new FirstLastImpl<PhysicalType>(out_type, options));
+    return Status::OK();
+  }
+
+  template <typename Type>
+  enable_if_physical_floating_point<Type, Status> Visit(const Type&) {
+    using PhysicalType = typename Type::PhysicalType;
+    state.reset(new FirstLastImpl<PhysicalType>(out_type, options));
+    return Status::OK();
+  }
+
+  template <typename Type>
+  enable_if_base_binary<Type, Status> Visit(const Type&) {
+    state.reset(new FirstLastImpl<Type>(out_type, options));
+    return Status::OK();
+  }
+
+  template <typename Type>
+  enable_if_t<std::is_same<Type, FixedSizeBinaryType>::value, Status> Visit(const Type&) {
+    state.reset(new FirstLastImpl<Type>(out_type, options));
+    return Status::OK();
+  }
+
+  Result<std::unique_ptr<KernelState>> Create() {
+    RETURN_NOT_OK(VisitTypeInline(in_type, this));
+    return std::move(state);
+  }
+};
+
 // ----------------------------------------------------------------------
 // MinMax implementation
+
 template <typename ArrowType, SimdLevel::type SimdLevel, typename Enable = void>
 struct MinMaxState {};
 
@@ -881,65 +943,6 @@ struct NullMinMaxImpl : public ScalarAggregator {
   }
 };
 
-// First/Last
-
-struct FirstLastInitState {
-  std::unique_ptr<KernelState> state;
-  KernelContext* ctx;
-  const DataType& in_type;
-  std::shared_ptr<DataType> out_type;
-  const ScalarAggregateOptions& options;
-
-  FirstLastInitState(KernelContext* ctx, const DataType& in_type,
-                     const std::shared_ptr<DataType>& out_type,
-                     const ScalarAggregateOptions& options)
-      : ctx(ctx), in_type(in_type), out_type(out_type), options(options) {}
-
-  Status Visit(const DataType& ty) {
-    return Status::NotImplemented("No first/last implemented for ", ty);
-  }
-
-  Status Visit(const HalfFloatType& ty) {
-    return Status::NotImplemented("No first/last implemented for ", ty);
-  }
-
-  Status Visit(const BooleanType&) {
-    state.reset(new FirstLastImpl<BooleanType>(out_type, options));
-    return Status::OK();
-  }
-
-  template <typename Type>
-  enable_if_physical_integer<Type, Status> Visit(const Type&) {
-    using PhysicalType = typename Type::PhysicalType;
-    state.reset(new FirstLastImpl<PhysicalType>(out_type, options));
-    return Status::OK();
-  }
-
-  template <typename Type>
-  enable_if_physical_floating_point<Type, Status> Visit(const Type&) {
-    using PhysicalType = typename Type::PhysicalType;
-    state.reset(new FirstLastImpl<PhysicalType>(out_type, options));
-    return Status::OK();
-  }
-
-  template <typename Type>
-  enable_if_base_binary<Type, Status> Visit(const Type&) {
-    state.reset(new FirstLastImpl<Type>(out_type, options));
-    return Status::OK();
-  }
-
-  template <typename Type>
-  enable_if_t<std::is_same<Type, FixedSizeBinaryType>::value, Status> Visit(const Type&) {
-    state.reset(new FirstLastImpl<Type>(out_type, options));
-    return Status::OK();
-  }
-
-  Result<std::unique_ptr<KernelState>> Create() {
-    RETURN_NOT_OK(VisitTypeInline(in_type, this));
-    return std::move(state);
-  }
-};
-
 template <SimdLevel::type SimdLevel>
 struct MinMaxInitState {
   std::unique_ptr<KernelState> state;
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 1358b0341ed..a99648c6264 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -289,11 +289,6 @@ struct SumImplDefault : public SumImpl<ArrowType, SimdLevel::NONE> {
   using SumImpl<ArrowType, SimdLevel::NONE>::SumImpl;
 };
 
-template <typename ArrowType>
-struct MeanImplDefault : public MeanImpl<ArrowType, SimdLevel::NONE> {
-  using MeanImpl<ArrowType, SimdLevel::NONE>::MeanImpl;
-};
-
 Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
                                              const KernelInitArgs& args) {
   SumLikeInit<SumImplDefault> visitor(
@@ -302,6 +297,14 @@ Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
   return visitor.Create();
 }
 
+// ----------------------------------------------------------------------
+// Mean implementation
+
+template <typename ArrowType>
+struct MeanImplDefault : public MeanImpl<ArrowType, SimdLevel::NONE> {
+  using MeanImpl<ArrowType, SimdLevel::NONE>::MeanImpl;
+};
+
 Result<std::unique_ptr<KernelState>> MeanInit(KernelContext* ctx,
                                               const KernelInitArgs& args) {
   MeanKernelInit<MeanImplDefault> visitor(
@@ -495,8 +498,8 @@ void AddFirstOrLastAggKernel(ScalarAggregateFunction* func,
 // ----------------------------------------------------------------------
 // MinMax implementation
 
-Result<std::unique_ptr<KernelState>> MinMaxInit(KernelContext* ctx,
-                                                const KernelInitArgs& args) {
+Result<std::unique_ptr<KernelState>> MinMaxInitNative(KernelContext* ctx,
+                                                      const KernelInitArgs& args) {
   ARROW_ASSIGN_OR_RAISE(TypeHolder out_type,
                         args.kernel->signature->out_type().Resolve(ctx, args.inputs));
   MinMaxInitState<SimdLevel::NONE> visitor(
@@ -1127,14 +1130,14 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   // Add min max function
   func = std::make_shared<ScalarAggregateFunction>("min_max", Arity::Unary(), min_max_doc,
                                                    &default_scalar_aggregate_options);
-  AddMinMaxKernels(MinMaxInit, {null(), boolean()}, func.get());
-  AddMinMaxKernels(MinMaxInit, NumericTypes(), func.get());
-  AddMinMaxKernels(MinMaxInit, TemporalTypes(), func.get());
-  AddMinMaxKernels(MinMaxInit, BaseBinaryTypes(), func.get());
-  AddMinMaxKernel(MinMaxInit, Type::FIXED_SIZE_BINARY, func.get());
-  AddMinMaxKernel(MinMaxInit, Type::INTERVAL_MONTHS, func.get());
-  AddMinMaxKernel(MinMaxInit, Type::DECIMAL128, func.get());
-  AddMinMaxKernel(MinMaxInit, Type::DECIMAL256, func.get());
+  AddMinMaxKernels(MinMaxInitNative, {null(), boolean()}, func.get());
+  AddMinMaxKernels(MinMaxInitNative, NumericTypes(), func.get());
+  AddMinMaxKernels(MinMaxInitNative, TemporalTypes(), func.get());
+  AddMinMaxKernels(MinMaxInitNative, BaseBinaryTypes(), func.get());
+  AddMinMaxKernel(MinMaxInitNative, Type::FIXED_SIZE_BINARY, func.get());
+  AddMinMaxKernel(MinMaxInitNative, Type::INTERVAL_MONTHS, func.get());
+  AddMinMaxKernel(MinMaxInitNative, Type::DECIMAL128, func.get());
+  AddMinMaxKernel(MinMaxInitNative, Type::DECIMAL256, func.get());
   // Add the SIMD variants for min max
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (cpu_info->IsSupported(arrow::internal::CpuInfo::AVX2)) {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index a597b0a0cf9..b71bc4ecd41 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -49,11 +49,6 @@ struct SumImplAvx2 : public SumImpl<ArrowType, SimdLevel::AVX2> {
   using SumImpl<ArrowType, SimdLevel::AVX2>::SumImpl;
 };
 
-template <typename ArrowType>
-struct MeanImplAvx2 : public MeanImpl<ArrowType, SimdLevel::AVX2> {
-  using MeanImpl<ArrowType, SimdLevel::AVX2>::MeanImpl;
-};
-
 Result<std::unique_ptr<KernelState>> SumInitAvx2(KernelContext* ctx,
                                                  const KernelInitArgs& args) {
   SumLikeInit<SumImplAvx2> visitor(
@@ -62,6 +57,20 @@ Result<std::unique_ptr<KernelState>> SumInitAvx2(KernelContext* ctx,
   return visitor.Create();
 }
 
+void AddSumAvx2AggKernels(ScalarAggregateFunction* func) {
+  AddBasicAggKernels(SumInitAvx2, SignedIntTypes(), int64(), func, SimdLevel::AVX2);
+  AddBasicAggKernels(SumInitAvx2, UnsignedIntTypes(), uint64(), func, SimdLevel::AVX2);
+  AddBasicAggKernels(SumInitAvx2, FloatingPointTypes(), float64(), func, SimdLevel::AVX2);
+}
+
+// ----------------------------------------------------------------------
+// Mean implementation
+
+template <typename ArrowType>
+struct MeanImplAvx2 : public MeanImpl<ArrowType, SimdLevel::AVX2> {
+  using MeanImpl<ArrowType, SimdLevel::AVX2>::MeanImpl;
+};
+
 Result<std::unique_ptr<KernelState>> MeanInitAvx2(KernelContext* ctx,
                                                   const KernelInitArgs& args) {
   SumLikeInit<MeanImplAvx2> visitor(
@@ -70,6 +79,10 @@ Result<std::unique_ptr<KernelState>> MeanInitAvx2(KernelContext* ctx,
   return visitor.Create();
 }
 
+void AddMeanAvx2AggKernels(ScalarAggregateFunction* func) {
+  AddBasicAggKernels(MeanInitAvx2, NumericTypes(), float64(), func, SimdLevel::AVX2);
+}
+
 // ----------------------------------------------------------------------
 // MinMax implementation
 
@@ -83,16 +96,6 @@ Result<std::unique_ptr<KernelState>> MinMaxInitAvx2(KernelContext* ctx,
   return visitor.Create();
 }
 
-void AddSumAvx2AggKernels(ScalarAggregateFunction* func) {
-  AddBasicAggKernels(SumInitAvx2, SignedIntTypes(), int64(), func, SimdLevel::AVX2);
-  AddBasicAggKernels(SumInitAvx2, UnsignedIntTypes(), uint64(), func, SimdLevel::AVX2);
-  AddBasicAggKernels(SumInitAvx2, FloatingPointTypes(), float64(), func, SimdLevel::AVX2);
-}
-
-void AddMeanAvx2AggKernels(ScalarAggregateFunction* func) {
-  AddBasicAggKernels(MeanInitAvx2, NumericTypes(), float64(), func, SimdLevel::AVX2);
-}
-
 void AddMinMaxAvx2AggKernels(ScalarAggregateFunction* func) {
   // Enable int types for AVX2 variants.
   // No auto vectorize for float/double as it use fmin/fmax which has NaN handling.
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 544a2091e37..aa4af7da43e 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -49,11 +49,6 @@ struct SumImplAvx512 : public SumImpl<ArrowType, SimdLevel::AVX512> {
   using SumImpl<ArrowType, SimdLevel::AVX512>::SumImpl;
 };
 
-template <typename ArrowType>
-struct MeanImplAvx512 : public MeanImpl<ArrowType, SimdLevel::AVX512> {
-  using MeanImpl<ArrowType, SimdLevel::AVX512>::MeanImpl;
-};
-
 Result<std::unique_ptr<KernelState>> SumInitAvx512(KernelContext* ctx,
                                                    const KernelInitArgs& args) {
   SumLikeInit<SumImplAvx512> visitor(
@@ -62,6 +57,22 @@ Result<std::unique_ptr<KernelState>> SumInitAvx512(KernelContext* ctx,
   return visitor.Create();
 }
 
+void AddSumAvx512AggKernels(ScalarAggregateFunction* func) {
+  AddBasicAggKernels(SumInitAvx512, SignedIntTypes(), int64(), func, SimdLevel::AVX512);
+  AddBasicAggKernels(SumInitAvx512, UnsignedIntTypes(), uint64(), func,
+                     SimdLevel::AVX512);
+  AddBasicAggKernels(SumInitAvx512, FloatingPointTypes(), float64(), func,
+                     SimdLevel::AVX512);
+}
+
+// ----------------------------------------------------------------------
+// Mean implementation
+
+template <typename ArrowType>
+struct MeanImplAvx512 : public MeanImpl<ArrowType, SimdLevel::AVX512> {
+  using MeanImpl<ArrowType, SimdLevel::AVX512>::MeanImpl;
+};
+
 Result<std::unique_ptr<KernelState>> MeanInitAvx512(KernelContext* ctx,
                                                     const KernelInitArgs& args) {
   SumLikeInit<MeanImplAvx512> visitor(
@@ -70,6 +81,10 @@ Result<std::unique_ptr<KernelState>> MeanInitAvx512(KernelContext* ctx,
   return visitor.Create();
 }
 
+void AddMeanAvx512AggKernels(ScalarAggregateFunction* func) {
+  AddBasicAggKernels(MeanInitAvx512, NumericTypes(), float64(), func, SimdLevel::AVX512);
+}
+
 // ----------------------------------------------------------------------
 // MinMax implementation
 
@@ -83,18 +98,6 @@ Result<std::unique_ptr<KernelState>> MinMaxInitAvx512(KernelContext* ctx,
   return visitor.Create();
 }
 
-void AddSumAvx512AggKernels(ScalarAggregateFunction* func) {
-  AddBasicAggKernels(SumInitAvx512, SignedIntTypes(), int64(), func, SimdLevel::AVX512);
-  AddBasicAggKernels(SumInitAvx512, UnsignedIntTypes(), uint64(), func,
-                     SimdLevel::AVX512);
-  AddBasicAggKernels(SumInitAvx512, FloatingPointTypes(), float64(), func,
-                     SimdLevel::AVX512);
-}
-
-void AddMeanAvx512AggKernels(ScalarAggregateFunction* func) {
-  AddBasicAggKernels(MeanInitAvx512, NumericTypes(), float64(), func, SimdLevel::AVX512);
-}
-
 void AddMinMaxAvx512AggKernels(ScalarAggregateFunction* func) {
   // Enable 32/64 int types for avx512 variants, no advantage on 8/16 int.
   AddMinMaxKernels(MinMaxInitAvx512, {int32(), uint32(), int64(), uint64()}, func,
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index f111e56f1d8..5cc3a558b1e 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -27,6 +27,8 @@
 
 namespace arrow::compute::internal {
 
+// aggregate_basic.cc
+
 void AddBasicAggKernels(KernelInit init,
                         const std::vector<std::shared_ptr<DataType>>& types,
                         std::shared_ptr<DataType> out_ty, ScalarAggregateFunction* func,
@@ -40,11 +42,14 @@ void AddMinMaxKernel(KernelInit init, internal::detail::GetTypeId get_id,
                      ScalarAggregateFunction* func,
                      SimdLevel::type simd_level = SimdLevel::NONE);
 
-// SIMD variants for kernels
+// aggregate_basic_avx2.cc
+
 void AddSumAvx2AggKernels(ScalarAggregateFunction* func);
 void AddMeanAvx2AggKernels(ScalarAggregateFunction* func);
 void AddMinMaxAvx2AggKernels(ScalarAggregateFunction* func);
 
+// aggregate_basic_avx512.cc
+
 void AddSumAvx512AggKernels(ScalarAggregateFunction* func);
 void AddMeanAvx512AggKernels(ScalarAggregateFunction* func);
 void AddMinMaxAvx512AggKernels(ScalarAggregateFunction* func);

From dd6287d8e3c45628fdc8e3ed2e5a549c26f9abfb Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 15 Aug 2024 19:56:12 -0300
Subject: [PATCH 05/16] Use Native instead of Default as non-SIMD suffix

---
 cpp/src/arrow/compute/kernels/aggregate_basic.cc | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index a99648c6264..ac122af53c7 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -285,13 +285,13 @@ void AddCountDistinctKernels(ScalarAggregateFunction* func) {
 // Sum implementation
 
 template <typename ArrowType>
-struct SumImplDefault : public SumImpl<ArrowType, SimdLevel::NONE> {
+struct SumImplNative : public SumImpl<ArrowType, SimdLevel::NONE> {
   using SumImpl<ArrowType, SimdLevel::NONE>::SumImpl;
 };
 
 Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
                                              const KernelInitArgs& args) {
-  SumLikeInit<SumImplDefault> visitor(
+  SumLikeInit<SumImplNative> visitor(
       ctx, args.inputs[0].GetSharedPtr(),
       static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
@@ -301,13 +301,13 @@ Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
 // Mean implementation
 
 template <typename ArrowType>
-struct MeanImplDefault : public MeanImpl<ArrowType, SimdLevel::NONE> {
+struct MeanImplNative : public MeanImpl<ArrowType, SimdLevel::NONE> {
   using MeanImpl<ArrowType, SimdLevel::NONE>::MeanImpl;
 };
 
 Result<std::unique_ptr<KernelState>> MeanInit(KernelContext* ctx,
                                               const KernelInitArgs& args) {
-  MeanKernelInit<MeanImplDefault> visitor(
+  MeanKernelInit<MeanImplNative> visitor(
       ctx, args.inputs[0].GetSharedPtr(),
       static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();

From cacd070ab2c5bbb89cd364b3f7478bb575d867d8 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 15 Aug 2024 20:41:07 -0300
Subject: [PATCH 06/16] Please the linter

---
 cpp/src/arrow/compute/kernels/aggregate_basic-inl.h     | 8 ++++----
 cpp/src/arrow/compute/kernels/aggregate_basic.cc        | 1 +
 cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc   | 1 +
 cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc | 1 +
 4 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
index 37ab9a9e611..9b9b6d07c6c 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
@@ -182,7 +182,7 @@ struct SumLikeInit {
   }
 
   Result<std::unique_ptr<KernelState>> Create() {
-    RETURN_NOT_OK(VisitTypeInline(*type, this));
+    ARROW_RETURN_NOT_OK(VisitTypeInline(*type, this));
     return std::move(state);
   }
 };
@@ -475,7 +475,7 @@ struct FirstLastImpl : public ScalarAggregator {
             break;
           }
         }
-        DCHECK_GE(last_i, first_i);
+        assert(last_i >= first_i);
         this->state.MergeOne(arr.GetView(first_i));
         this->state.MergeOne(arr.GetView(last_i));
       }
@@ -585,7 +585,7 @@ struct FirstLastInitState {
   }
 
   Result<std::unique_ptr<KernelState>> Create() {
-    RETURN_NOT_OK(VisitTypeInline(in_type, this));
+    ARROW_RETURN_NOT_OK(VisitTypeInline(in_type, this));
     return std::move(state);
   }
 };
@@ -1000,7 +1000,7 @@ struct MinMaxInitState {
   }
 
   Result<std::unique_ptr<KernelState>> Create() {
-    RETURN_NOT_OK(VisitTypeInline(in_type, this));
+    ARROW_RETURN_NOT_OK(VisitTypeInline(in_type, this));
     return std::move(state);
   }
 };
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index ac122af53c7..6b1fa98c264 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cassert>
 #include <cmath>
 #include <memory>
 #include <type_traits>
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index b71bc4ecd41..26772714d15 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cassert>
 #include <cmath>
 #include <type_traits>
 #include <utility>
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index aa4af7da43e..6422df62821 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <cassert>
 #include <cmath>
 #include <type_traits>
 #include <utility>

From 7aca53437161e0caf46b8b0962d0eec895e11b49 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Fri, 16 Aug 2024 15:51:21 -0300
Subject: [PATCH 07/16] Rename -inl.h to -inl.cc

---
 .../kernels/{aggregate_basic-inl.h => aggregate_basic-inl.cc} | 4 ++--
 cpp/src/arrow/compute/kernels/aggregate_basic.cc              | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc         | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc       | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)
 rename cpp/src/arrow/compute/kernels/{aggregate_basic-inl.h => aggregate_basic-inl.cc} (99%)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc
similarity index 99%
rename from cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
rename to cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc
index 9b9b6d07c6c..063a628ffb4 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc
@@ -15,12 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// -inl.h file to be included in compilation unit where kernels are meant to be
+// -inl.cc file to be included in compilation unit where kernels are meant to be
 // compiled auto-vectorized by the compiler with different SIMD levels passed
 // as compiler flags.
 //
 // It contains no includes to avoid double inclusion in the compilation unit
-// that includes this -inl.h file.
+// that includes this -inl.cc file.
 
 namespace arrow::compute::internal {
 namespace {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 6b1fa98c264..05079f1fa07 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -37,7 +37,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic-inl.h"
+#include "arrow/compute/kernels/aggregate_basic-inl.cc"  // NOLINT
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index 26772714d15..c5cf1dd6b9e 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -36,7 +36,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic-inl.h"
+#include "arrow/compute/kernels/aggregate_basic-inl.cc"  // NOLINT
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 6422df62821..8614ab8e2c0 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -36,7 +36,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic-inl.h"
+#include "arrow/compute/kernels/aggregate_basic-inl.cc"  // NOLINT
 
 namespace arrow {
 namespace compute {

From 3359c5b3c35115d8fa1a34191c9f56d3de77b46b Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Fri, 16 Aug 2024 11:57:54 -0300
Subject: [PATCH 08/16] Allow -inl.{cc,h} filenames

---
 cpp/build-support/lint_cpp_cli.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/cpp/build-support/lint_cpp_cli.py b/cpp/build-support/lint_cpp_cli.py
index 47abd53fe92..c1aaec96172 100755
--- a/cpp/build-support/lint_cpp_cli.py
+++ b/cpp/build-support/lint_cpp_cli.py
@@ -107,7 +107,9 @@ def lint_files():
 
             # Lint file name, except for pkg-config templates
             if not filename.endswith('.pc.in'):
-                if '-' in filename:
+                # - is not allowed in filenames, except for -inl.{h,cc} files
+                if '-' in filename and not (filename.endswith('-inl.cc') or
+                                            filename.endswith('-inl.h')):
                     why = ("Please use underscores, not hyphens, "
                            "in source file names")
                     yield full_path, why, 0, full_path

From 2d8abc7006b152176bea191a6e637fbf38f424e9 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 19 Aug 2024 12:30:56 -0300
Subject: [PATCH 09/16] Remove now unecessary extra includes

---
 .../compute/kernels/aggregate_basic-inl.cc      | 16 ++++++++++++++++
 .../arrow/compute/kernels/aggregate_basic.cc    | 12 ------------
 .../compute/kernels/aggregate_basic_avx2.cc     | 17 -----------------
 .../compute/kernels/aggregate_basic_avx512.cc   | 17 -----------------
 4 files changed, 16 insertions(+), 46 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc
index 063a628ffb4..57a6a827f03 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc
@@ -22,6 +22,22 @@
 // It contains no includes to avoid double inclusion in the compilation unit
 // that includes this -inl.cc file.
 
+#include <cassert>
+#include <cmath>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "arrow/compute/api_aggregate.h"
+#include "arrow/compute/kernels/aggregate_internal.h"
+#include "arrow/compute/kernels/codegen_internal.h"
+#include "arrow/status.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/align_util.h"
+#include "arrow/util/bit_block_counter.h"
+#include "arrow/util/decimal.h"
+
 namespace arrow::compute::internal {
 namespace {
 
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 05079f1fa07..8eaacf6d3f4 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -15,24 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <cassert>
-#include <cmath>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
 #include "arrow/compute/api_aggregate.h"
 #include "arrow/compute/kernels/aggregate_basic_internal.h"
 #include "arrow/compute/kernels/aggregate_internal.h"
-#include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/compute/kernels/util_internal.h"
-#include "arrow/type.h"
-#include "arrow/type_traits.h"
-#include "arrow/util/align_util.h"
-#include "arrow/util/bit_block_counter.h"
 #include "arrow/util/cpu_info.h"
-#include "arrow/util/decimal.h"
 #include "arrow/util/hashing.h"
 
 // Include templated definitions for aggregate kernels that must compiled here
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index c5cf1dd6b9e..203acce732d 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -15,24 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <cassert>
-#include <cmath>
-#include <type_traits>
-#include <utility>
-
-#include "arrow/compute/api_aggregate.h"
 #include "arrow/compute/kernels/aggregate_basic_internal.h"
-#include "arrow/compute/kernels/aggregate_internal.h"
-#include "arrow/compute/kernels/codegen_internal.h"
-#include "arrow/compute/kernels/common_internal.h"
-#include "arrow/compute/kernels/util_internal.h"
-#include "arrow/type.h"
-#include "arrow/type_traits.h"
-#include "arrow/util/align_util.h"
-#include "arrow/util/bit_block_counter.h"
-#include "arrow/util/cpu_info.h"
-#include "arrow/util/decimal.h"
-#include "arrow/util/hashing.h"
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 8614ab8e2c0..5a005e8c25c 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -15,24 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <cassert>
-#include <cmath>
-#include <type_traits>
-#include <utility>
-
-#include "arrow/compute/api_aggregate.h"
 #include "arrow/compute/kernels/aggregate_basic_internal.h"
-#include "arrow/compute/kernels/aggregate_internal.h"
-#include "arrow/compute/kernels/codegen_internal.h"
-#include "arrow/compute/kernels/common_internal.h"
-#include "arrow/compute/kernels/util_internal.h"
-#include "arrow/type.h"
-#include "arrow/type_traits.h"
-#include "arrow/util/align_util.h"
-#include "arrow/util/bit_block_counter.h"
-#include "arrow/util/cpu_info.h"
-#include "arrow/util/decimal.h"
-#include "arrow/util/hashing.h"
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.

From ec34acda04e59f5ac974e0b827703d4a313a6517 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 19 Aug 2024 12:32:52 -0300
Subject: [PATCH 10/16] Undo s/Default/Native

---
 cpp/src/arrow/compute/kernels/aggregate_basic.cc | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 8eaacf6d3f4..0e0c2641f50 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -274,13 +274,13 @@ void AddCountDistinctKernels(ScalarAggregateFunction* func) {
 // Sum implementation
 
 template <typename ArrowType>
-struct SumImplNative : public SumImpl<ArrowType, SimdLevel::NONE> {
+struct SumImplDefault : public SumImpl<ArrowType, SimdLevel::NONE> {
   using SumImpl<ArrowType, SimdLevel::NONE>::SumImpl;
 };
 
 Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
                                              const KernelInitArgs& args) {
-  SumLikeInit<SumImplNative> visitor(
+  SumLikeInit<SumImplDefault> visitor(
       ctx, args.inputs[0].GetSharedPtr(),
       static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();
@@ -290,13 +290,13 @@ Result<std::unique_ptr<KernelState>> SumInit(KernelContext* ctx,
 // Mean implementation
 
 template <typename ArrowType>
-struct MeanImplNative : public MeanImpl<ArrowType, SimdLevel::NONE> {
+struct MeanImplDefault : public MeanImpl<ArrowType, SimdLevel::NONE> {
   using MeanImpl<ArrowType, SimdLevel::NONE>::MeanImpl;
 };
 
 Result<std::unique_ptr<KernelState>> MeanInit(KernelContext* ctx,
                                               const KernelInitArgs& args) {
-  MeanKernelInit<MeanImplNative> visitor(
+  MeanKernelInit<MeanImplDefault> visitor(
       ctx, args.inputs[0].GetSharedPtr(),
       static_cast<const ScalarAggregateOptions&>(*args.options));
   return visitor.Create();

From ae52c5d04e0dde1db024e34068dd25749932b460 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 19 Aug 2024 12:42:35 -0300
Subject: [PATCH 11/16] Rename -inl.cc to .inc

---
 cpp/src/arrow/compute/kernels/aggregate_basic.cc              | 2 +-
 .../kernels/{aggregate_basic-inl.cc => aggregate_basic.inc}   | 4 ++--
 cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc         | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc       | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)
 rename cpp/src/arrow/compute/kernels/{aggregate_basic-inl.cc => aggregate_basic.inc} (99%)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 0e0c2641f50..87e6fdc2905 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -25,7 +25,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic-inl.cc"  // NOLINT
+#include "arrow/compute/kernels/aggregate_basic.inc"
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.inc
similarity index 99%
rename from cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc
rename to cpp/src/arrow/compute/kernels/aggregate_basic.inc
index 57a6a827f03..ae4a32ca795 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic-inl.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.inc
@@ -15,12 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// -inl.cc file to be included in compilation unit where kernels are meant to be
+// .inc file to be included in compilation unit where kernels are meant to be
 // compiled auto-vectorized by the compiler with different SIMD levels passed
 // as compiler flags.
 //
 // It contains no includes to avoid double inclusion in the compilation unit
-// that includes this -inl.cc file.
+// that includes this .inc file.
 
 #include <cassert>
 #include <cmath>
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index 203acce732d..773004d33d8 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -19,7 +19,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic-inl.cc"  // NOLINT
+#include "arrow/compute/kernels/aggregate_basic.inc"
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 5a005e8c25c..fd7b0c316a8 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -19,7 +19,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic-inl.cc"  // NOLINT
+#include "arrow/compute/kernels/aggregate_basic.inc"
 
 namespace arrow {
 namespace compute {

From 8a30725aefa230c1d49e1a5b43dfcf96ca90b26d Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 19 Aug 2024 12:43:51 -0300
Subject: [PATCH 12/16] Undo lint_cpp_cli.py changes

---
 cpp/build-support/lint_cpp_cli.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/cpp/build-support/lint_cpp_cli.py b/cpp/build-support/lint_cpp_cli.py
index c1aaec96172..47abd53fe92 100755
--- a/cpp/build-support/lint_cpp_cli.py
+++ b/cpp/build-support/lint_cpp_cli.py
@@ -107,9 +107,7 @@ def lint_files():
 
             # Lint file name, except for pkg-config templates
             if not filename.endswith('.pc.in'):
-                # - is not allowed in filenames, except for -inl.{h,cc} files
-                if '-' in filename and not (filename.endswith('-inl.cc') or
-                                            filename.endswith('-inl.h')):
+                if '-' in filename:
                     why = ("Please use underscores, not hyphens, "
                            "in source file names")
                     yield full_path, why, 0, full_path

From b6f4af4aa8a702e84e9b8c5db924fe99dcee9b2a Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 19 Aug 2024 17:43:05 -0300
Subject: [PATCH 13/16] fixup! Undo s/Default/Native

---
 .../arrow/compute/kernels/aggregate_basic.cc  | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 87e6fdc2905..7d4ce45de49 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -487,8 +487,8 @@ void AddFirstOrLastAggKernel(ScalarAggregateFunction* func,
 // ----------------------------------------------------------------------
 // MinMax implementation
 
-Result<std::unique_ptr<KernelState>> MinMaxInitNative(KernelContext* ctx,
-                                                      const KernelInitArgs& args) {
+Result<std::unique_ptr<KernelState>> MinMaxInitDefault(KernelContext* ctx,
+                                                       const KernelInitArgs& args) {
   ARROW_ASSIGN_OR_RAISE(TypeHolder out_type,
                         args.kernel->signature->out_type().Resolve(ctx, args.inputs));
   MinMaxInitState<SimdLevel::NONE> visitor(
@@ -1119,14 +1119,14 @@ void RegisterScalarAggregateBasic(FunctionRegistry* registry) {
   // Add min max function
   func = std::make_shared<ScalarAggregateFunction>("min_max", Arity::Unary(), min_max_doc,
                                                    &default_scalar_aggregate_options);
-  AddMinMaxKernels(MinMaxInitNative, {null(), boolean()}, func.get());
-  AddMinMaxKernels(MinMaxInitNative, NumericTypes(), func.get());
-  AddMinMaxKernels(MinMaxInitNative, TemporalTypes(), func.get());
-  AddMinMaxKernels(MinMaxInitNative, BaseBinaryTypes(), func.get());
-  AddMinMaxKernel(MinMaxInitNative, Type::FIXED_SIZE_BINARY, func.get());
-  AddMinMaxKernel(MinMaxInitNative, Type::INTERVAL_MONTHS, func.get());
-  AddMinMaxKernel(MinMaxInitNative, Type::DECIMAL128, func.get());
-  AddMinMaxKernel(MinMaxInitNative, Type::DECIMAL256, func.get());
+  AddMinMaxKernels(MinMaxInitDefault, {null(), boolean()}, func.get());
+  AddMinMaxKernels(MinMaxInitDefault, NumericTypes(), func.get());
+  AddMinMaxKernels(MinMaxInitDefault, TemporalTypes(), func.get());
+  AddMinMaxKernels(MinMaxInitDefault, BaseBinaryTypes(), func.get());
+  AddMinMaxKernel(MinMaxInitDefault, Type::FIXED_SIZE_BINARY, func.get());
+  AddMinMaxKernel(MinMaxInitDefault, Type::INTERVAL_MONTHS, func.get());
+  AddMinMaxKernel(MinMaxInitDefault, Type::DECIMAL128, func.get());
+  AddMinMaxKernel(MinMaxInitDefault, Type::DECIMAL256, func.get());
   // Add the SIMD variants for min max
 #if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (cpu_info->IsSupported(arrow::internal::CpuInfo::AVX2)) {

From 2030b8a20231d3464a75aa084166216ac59e58f5 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 22 Aug 2024 19:51:24 -0300
Subject: [PATCH 14/16] Rename .inc to .inc.cc

---
 cpp/src/arrow/compute/kernels/aggregate_basic.cc              | 2 +-
 .../kernels/{aggregate_basic.inc => aggregate_basic.inc.cc}   | 4 ++--
 cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc         | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc       | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)
 rename cpp/src/arrow/compute/kernels/{aggregate_basic.inc => aggregate_basic.inc.cc} (99%)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 7d4ce45de49..2c9cc14c5d7 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -25,7 +25,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc"
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.inc b/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
similarity index 99%
rename from cpp/src/arrow/compute/kernels/aggregate_basic.inc
rename to cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
index ae4a32ca795..f2151e0a9e0 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.inc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.inc.cc
@@ -15,12 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// .inc file to be included in compilation unit where kernels are meant to be
+// .inc.cc file to be included in compilation unit where kernels are meant to be
 // compiled auto-vectorized by the compiler with different SIMD levels passed
 // as compiler flags.
 //
 // It contains no includes to avoid double inclusion in the compilation unit
-// that includes this .inc file.
+// that includes this .inc.cc file.
 
 #include <cassert>
 #include <cmath>
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index 773004d33d8..d902454e8d5 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -19,7 +19,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc"
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index fd7b0c316a8..da3d12f8f7e 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -19,7 +19,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc"
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"
 
 namespace arrow {
 namespace compute {

From 370b6a3326cb47bc2f931aca4cb03ee1a6f73b21 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Wed, 28 Aug 2024 13:52:36 -0300
Subject: [PATCH 15/16] NOLINT the .cc inclusions

---
 cpp/src/arrow/compute/kernels/aggregate_basic.cc        | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc   | 2 +-
 cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 2c9cc14c5d7..26c4dcefd4c 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -25,7 +25,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc.cc"
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NOLINT
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index d902454e8d5..c364d922038 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -19,7 +19,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc.cc"
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NONLINT
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index da3d12f8f7e..49904fc717d 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -19,7 +19,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc.cc"
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NONLINT
 
 namespace arrow {
 namespace compute {

From 447fbc9eb2094eaa1c69fb8204fd2129da0eafe6 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 3 Sep 2024 15:33:04 +0200
Subject: [PATCH 16/16] Fix lint + make more definitions anonymous/static

---
 cpp/src/arrow/compute/kernels/aggregate_basic.cc   |  2 +-
 .../arrow/compute/kernels/aggregate_basic_avx2.cc  | 14 +++++++++++++-
 .../compute/kernels/aggregate_basic_avx512.cc      | 14 +++++++++++++-
 3 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic.cc b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
index 26c4dcefd4c..b545d8bcc10 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic.cc
@@ -25,7 +25,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NOLINT
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NOLINT(build/include)
 
 namespace arrow {
 namespace compute {
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
index c364d922038..a1a6a95c5e1 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx2.cc
@@ -19,7 +19,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NONLINT
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NOLINT(build/include)
 
 namespace arrow {
 namespace compute {
@@ -28,6 +28,8 @@ namespace internal {
 // ----------------------------------------------------------------------
 // Sum implementation
 
+namespace {
+
 template <typename ArrowType>
 struct SumImplAvx2 : public SumImpl<ArrowType, SimdLevel::AVX2> {
   using SumImpl<ArrowType, SimdLevel::AVX2>::SumImpl;
@@ -41,6 +43,8 @@ Result<std::unique_ptr<KernelState>> SumInitAvx2(KernelContext* ctx,
   return visitor.Create();
 }
 
+}  // namespace
+
 void AddSumAvx2AggKernels(ScalarAggregateFunction* func) {
   AddBasicAggKernels(SumInitAvx2, SignedIntTypes(), int64(), func, SimdLevel::AVX2);
   AddBasicAggKernels(SumInitAvx2, UnsignedIntTypes(), uint64(), func, SimdLevel::AVX2);
@@ -50,6 +54,8 @@ void AddSumAvx2AggKernels(ScalarAggregateFunction* func) {
 // ----------------------------------------------------------------------
 // Mean implementation
 
+namespace {
+
 template <typename ArrowType>
 struct MeanImplAvx2 : public MeanImpl<ArrowType, SimdLevel::AVX2> {
   using MeanImpl<ArrowType, SimdLevel::AVX2>::MeanImpl;
@@ -63,6 +69,8 @@ Result<std::unique_ptr<KernelState>> MeanInitAvx2(KernelContext* ctx,
   return visitor.Create();
 }
 
+}  // namespace
+
 void AddMeanAvx2AggKernels(ScalarAggregateFunction* func) {
   AddBasicAggKernels(MeanInitAvx2, NumericTypes(), float64(), func, SimdLevel::AVX2);
 }
@@ -70,6 +78,8 @@ void AddMeanAvx2AggKernels(ScalarAggregateFunction* func) {
 // ----------------------------------------------------------------------
 // MinMax implementation
 
+namespace {
+
 Result<std::unique_ptr<KernelState>> MinMaxInitAvx2(KernelContext* ctx,
                                                     const KernelInitArgs& args) {
   ARROW_ASSIGN_OR_RAISE(TypeHolder out_type,
@@ -80,6 +90,8 @@ Result<std::unique_ptr<KernelState>> MinMaxInitAvx2(KernelContext* ctx,
   return visitor.Create();
 }
 
+}  // namespace
+
 void AddMinMaxAvx2AggKernels(ScalarAggregateFunction* func) {
   // Enable int types for AVX2 variants.
   // No auto vectorize for float/double as it use fmin/fmax which has NaN handling.
diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
index 49904fc717d..9dc490937a6 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_avx512.cc
@@ -19,7 +19,7 @@
 
 // Include templated definitions for aggregate kernels that must compiled here
 // with the SIMD level configured for this compilation unit in the build.
-#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NONLINT
+#include "arrow/compute/kernels/aggregate_basic.inc.cc"  // NOLINT(build/include)
 
 namespace arrow {
 namespace compute {
@@ -28,6 +28,8 @@ namespace internal {
 // ----------------------------------------------------------------------
 // Sum implementation
 
+namespace {
+
 template <typename ArrowType>
 struct SumImplAvx512 : public SumImpl<ArrowType, SimdLevel::AVX512> {
   using SumImpl<ArrowType, SimdLevel::AVX512>::SumImpl;
@@ -41,6 +43,8 @@ Result<std::unique_ptr<KernelState>> SumInitAvx512(KernelContext* ctx,
   return visitor.Create();
 }
 
+}  // namespace
+
 void AddSumAvx512AggKernels(ScalarAggregateFunction* func) {
   AddBasicAggKernels(SumInitAvx512, SignedIntTypes(), int64(), func, SimdLevel::AVX512);
   AddBasicAggKernels(SumInitAvx512, UnsignedIntTypes(), uint64(), func,
@@ -52,6 +56,8 @@ void AddSumAvx512AggKernels(ScalarAggregateFunction* func) {
 // ----------------------------------------------------------------------
 // Mean implementation
 
+namespace {
+
 template <typename ArrowType>
 struct MeanImplAvx512 : public MeanImpl<ArrowType, SimdLevel::AVX512> {
   using MeanImpl<ArrowType, SimdLevel::AVX512>::MeanImpl;
@@ -65,6 +71,8 @@ Result<std::unique_ptr<KernelState>> MeanInitAvx512(KernelContext* ctx,
   return visitor.Create();
 }
 
+}  // namespace
+
 void AddMeanAvx512AggKernels(ScalarAggregateFunction* func) {
   AddBasicAggKernels(MeanInitAvx512, NumericTypes(), float64(), func, SimdLevel::AVX512);
 }
@@ -72,6 +80,8 @@ void AddMeanAvx512AggKernels(ScalarAggregateFunction* func) {
 // ----------------------------------------------------------------------
 // MinMax implementation
 
+namespace {
+
 Result<std::unique_ptr<KernelState>> MinMaxInitAvx512(KernelContext* ctx,
                                                       const KernelInitArgs& args) {
   ARROW_ASSIGN_OR_RAISE(TypeHolder out_type,
@@ -82,6 +92,8 @@ Result<std::unique_ptr<KernelState>> MinMaxInitAvx512(KernelContext* ctx,
   return visitor.Create();
 }
 
+}  // namespace
+
 void AddMinMaxAvx512AggKernels(ScalarAggregateFunction* func) {
   // Enable 32/64 int types for avx512 variants, no advantage on 8/16 int.
   AddMinMaxKernels(MinMaxInitAvx512, {int32(), uint32(), int64(), uint64()}, func,