ARROW-46531: Refactor type_singleton using TypeTraits and VisitTypeIdInline.

Author: harshkumar-2005

cpp/src/arrow/scalar_test.cc

@@ -180,7 +180,8 @@ TEST(TestScalar, IdentityCast) {
     test_identity_cast_for_type(type);
   }
   for (auto& type : {
-           arrow::fixed_size_list(arrow::int32(), 20), arrow::list(arrow::int32()),
+           arrow::fixed_size_list(arrow::int32(), 20),
+           arrow::list(arrow::int32()),
            arrow::large_list(arrow::int32()),
            // TODO(GH-45430): CastTo for ListView is not implemented yet.
            // arrow::list_view(arrow::int32()), arrow::large_list_view(arrow::int32())

cpp/src/arrow/type.cc

@@ -38,6 +38,7 @@
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/table.h"
+#include "arrow/type_traits.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/decimal.h"
 #include "arrow/util/hash_util.h"
@@ -3552,4 +3553,26 @@ const std::vector<Type::type>& DecimalTypeIds() {
   return type_ids;
 }
 
+Result<std::shared_ptr<DataType>> type_singleton(Type::type id) {
+  struct Visitor {
+    Result<std::shared_ptr<DataType>> result;
+
+    template <typename T>
+    Status Visit(const T* type) {
+      if constexpr (TypeTraits<T>::is_parameter_free) {
+        result = TypeTraits<T>::type_singleton();
+        return Status::OK();
+      }
+      return Status::Invalid("Type ", T::type_id, " is not a parameter-free singleton type.");
+    }
+  };
+
+  Visitor visitor;
+  auto status = VisitTypeIdInline(id, &visitor);
+  if (!status.ok()) {
+    return Status::Invalid("Type ", id, " requires parameters or is not supported");
+  }
+  return visitor.result;
+}
+
 }  // namespace arrow

cpp/src/arrow/type.h

@@ -2645,4 +2645,17 @@ const std::vector<std::shared_ptr<DataType>>& PrimitiveTypes();
 ARROW_EXPORT
 const std::vector<Type::type>& DecimalTypeIds();
 
+/// \brief Create a data type instance from a type ID for parameter-free types
+///
+/// This function creates a data type instance for types that don't require
+/// additional parameters (where TypeTraits<T>::is_parameter_free is true).
+/// For types that require parameters (like TimestampType or ListType),
+/// this function will return an error.
+///
+/// \param[in] id The type ID to create a type instance for
+/// \return Result with a shared pointer to the created DataType instance,
+///         or an error if the type requires parameters
+ARROW_EXPORT
+Result<std::shared_ptr<DataType>> type_singleton(Type::type id);
+
 }  // namespace arrow

cpp/src/arrow/type_test.cc

@@ -38,9 +38,9 @@
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
-#include "arrow/util/logging.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/key_value_metadata.h"
+#include "arrow/util/logging.h"
 
 namespace arrow {
 
@@ -53,25 +53,12 @@ TEST(TestTypeId, AllTypeIds) {
 }
 
 TEST(TestTypeSingleton, ParameterFreeTypes) {
-  // Test successful cases - parameter-free types
+  // Test successful cases - parameter-free types (sample a few)
   std::vector<std::pair<Type::type, std::shared_ptr<DataType>>> cases = {
       {Type::NA, null()},
       {Type::BOOL, boolean()},
-      {Type::INT8, int8()},
-      {Type::INT16, int16()},
       {Type::INT32, int32()},
-      {Type::INT64, int64()},
-      {Type::UINT8, uint8()},
-      {Type::UINT16, uint16()},
-      {Type::UINT32, uint32()},
-      {Type::UINT64, uint64()},
-      {Type::HALF_FLOAT, float16()},
-      {Type::FLOAT, float32()},
-      {Type::DOUBLE, float64()},
       {Type::STRING, utf8()},
-      {Type::BINARY, binary()},
-      {Type::LARGE_STRING, large_utf8()},
-      {Type::LARGE_BINARY, large_binary()},
       {Type::DATE32, date32()},
   };
 
@@ -88,19 +75,18 @@ TEST(TestTypeSingleton, ParameterFreeTypes) {
 TEST(TestTypeSingleton, ParameterizedTypes) {
   // Test error cases - parameterized types
   std::vector<Type::type> parameterized_types = {
-      Type::TIMESTAMP,    Type::TIME32,           Type::TIME64,
-      Type::DURATION,     Type::FIXED_SIZE_BINARY, Type::DECIMAL128,
-      Type::LIST,         Type::LARGE_LIST,       Type::FIXED_SIZE_LIST,
-      Type::STRUCT,       Type::DICTIONARY,       Type::MAP,
-      Type::EXTENSION
-  };
+      Type::TIMESTAMP,         Type::TIME32,     Type::TIME64,     Type::DURATION,
+      Type::FIXED_SIZE_BINARY, Type::DECIMAL128, Type::LIST,       Type::LARGE_LIST,
+      Type::FIXED_SIZE_LIST,   Type::STRUCT,     Type::DICTIONARY, Type::MAP,
+      Type::EXTENSION};
 
   for (const auto type_id : parameterized_types) {
     SCOPED_TRACE("Testing type: " + std::to_string(static_cast<int>(type_id)));
     auto result = type_singleton(type_id);
     ASSERT_FALSE(result.ok());
     const auto& status = result.status();
-    EXPECT_THAT(status.message(), testing::HasSubstr("is not a parameter-free singleton type"));
+    EXPECT_THAT(status.message(),
+                testing::HasSubstr("is not a parameter-free singleton type"));
   }
 }
 
@@ -109,7 +95,8 @@ TEST(TestTypeSingleton, InvalidType) {
   auto result = type_singleton(static_cast<Type::type>(9999));
   ASSERT_FALSE(result.ok());
   const auto& status = result.status();
-  EXPECT_THAT(status.message(), testing::HasSubstr("requires parameters or is not supported"));
+  EXPECT_THAT(status.message(),
+              testing::HasSubstr("requires parameters or is not supported"));
 }
 
 template <typename ReprFunc>

cpp/src/arrow/type_traits.cc

@@ -22,68 +22,6 @@
 #include "arrow/type.h"
 #include "arrow/util/logging_internal.h"
 
-namespace arrow {
-
-Result<std::shared_ptr<DataType>> type_singleton(Type::type id) {
-  switch (id) {
-    case Type::NA:
-      return null();
-    case Type::BOOL:
-      return boolean();
-    case Type::INT8:
-      return int8();
-    case Type::INT16:
-      return int16();
-    case Type::INT32:
-      return int32();
-    case Type::INT64:
-      return int64();
-    case Type::UINT8:
-      return uint8();
-    case Type::UINT16:
-      return uint16();
-    case Type::UINT32:
-      return uint32();
-    case Type::UINT64:
-      return uint64();
-    case Type::HALF_FLOAT:
-      return float16();
-    case Type::FLOAT:
-      return float32();
-    case Type::DOUBLE:
-      return float64();
-    case Type::STRING:
-      return utf8();
-    case Type::BINARY:
-      return binary();
-    case Type::LARGE_STRING:
-      return large_utf8();
-    case Type::LARGE_BINARY:
-      return large_binary();
-    case Type::DATE32:
-      return date32();
-
-    // Explicitly handle known parameterized types
-    case Type::TIMESTAMP:
-    case Type::TIME32:
-    case Type::TIME64:
-    case Type::DURATION:
-    case Type::FIXED_SIZE_BINARY:
-    case Type::DECIMAL128:
-    case Type::LIST:
-    case Type::LARGE_LIST:
-    case Type::FIXED_SIZE_LIST:
-    case Type::STRUCT:
-    case Type::DICTIONARY:
-    case Type::MAP:
-    case Type::EXTENSION:
-      return Status::Invalid("Type ", id, " is not a parameter-free singleton type.");
-
-    default:
-      return Status::Invalid("Type ", id, " requires parameters or is not supported");
-  }
-}
-
 int RequiredValueAlignmentForBuffer(Type::type type_id, int buffer_index) {
   if (buffer_index == 2 && type_id == Type::DENSE_UNION) {
     // A dense union array is the only array (so far) that requires alignment

cpp/src/arrow/type_traits.h

@@ -608,8 +608,6 @@ struct TypeTraits<ExtensionType> {
 /// \param[in] id The type ID to create a type instance for
 /// \return Result with a shared pointer to the created DataType instance,
 ///         or an error if the type requires parameters
-ARROW_EXPORT
-Result<std::shared_ptr<DataType>> type_singleton(Type::type id);
 
 namespace internal {