fix: Find VeloxType singletons for CustomType when embedded in OpaqueType objects (#15829)

Summary:

## Background
- This diff is to fix a bug in the Types::create() method for CustomType.
- The bug manifests in the SignatureBinder.bind() operation failing to match for a CustomType argument.
- The CustomType is basically an OpaqueType object. 
- The root cause is that two different registries store OpaqueType objects.
   - Custom Type Registry → VeloxType singleton (correct name())
   - OpaqueSerdeRegistry → Base OpaqueType (name() = "OPAQUE")

-  When deserializing the custom type in Type::create() method, the code does not find VeloxType singleton, hence created an OpaqueType.
-  The CustomType returns its name in its custom name in the name() and toString() methods, whereas the OpaqueType returns "OPAQUE<demangled-name>" in its name/toString() methods.

## In this Diff
- The primary problem is that the CustomType has a Velox singleton for its type.
   However, type is serialized and deserialized, the type produced is an Opaque type, with custom type inside.
- In this diff, the velox deserialization correctly finds and produces the VeloxType singleton.

## Implementation Changes
- Types.cpp
   - Implemented searching and deserializing CustomType within OpaqueTypes in Type::create() method.

## Testing Changes
- OpaqueCustomTypesTest.cpp
   - Added test to serialize/deserialize a CustomType and confirm that VeloxType singleton is returned.

Differential Revision: D89564769

Author: Ashish Misra

velox/type/Type.cpp

@@ -203,8 +203,8 @@ TypePtr Type::create(const folly::dynamic& obj) {
   if (isDecimalName(typeName)) {
     return DECIMAL(obj["precision"].asInt(), obj["scale"].asInt());
   }
-  // Checks if 'typeName' specifies a custom type.
-  if (customTypeExists(typeName)) {
+
+  auto customTypeSingleton = [&](const std::string& typeName) {
     std::vector<TypeParameter> params;
     if (obj.find("cTypes") != obj.items().end()) {
       params.reserve(childTypes.size());
@@ -220,6 +220,11 @@ TypePtr Type::create(const folly::dynamic& obj) {
           deserializeEnumParam<std::string>(obj["kVarcharEnumParam"]));
     }
     return getCustomType(typeName, params);
+  };
+
+  // Checks if 'typeName' specifies a custom type.
+  if (customTypeExists(typeName)) {
+    return customTypeSingleton(typeName);
   }
 
   // 'typeName' must be a built-in type.
@@ -237,6 +242,9 @@ TypePtr Type::create(const folly::dynamic& obj) {
 
     case TypeKind::OPAQUE: {
       const auto& persistentName = obj["opaque"].asString();
+      if (customTypeExists(persistentName)) {
+        return customTypeSingleton(persistentName);
+      }
       const auto& registry = OpaqueSerdeRegistry::get();
       auto it = registry.reverse.find(persistentName);
       VELOX_USER_CHECK(

velox/type/tests/OpaqueCustomTypesTest.cpp

@@ -43,6 +43,13 @@ TEST(OpaqueCustomTypeTest, RegisterWithoutSerde) {
       /*deserialize=*/
       [](const std::string&) { return std::make_shared<TestCustomType>(); });
 
+  // Serialize and deserialize.
+  auto serializedCustomType = testCustomType->serialize();
+  EXPECT_EQ(testCustomTypeName, serializedCustomType["opaque"]);
+
+  auto deserializedType = Type::create(serializedCustomType);
+  EXPECT_EQ(testCustomType, deserializedType);
+
   // Trying to re-register serialization/deserialization should fail.
   VELOX_ASSERT_THROW(
       TestCustomTypeRegister::registerSerialization(
@@ -70,6 +77,13 @@ TEST(OpaqueCustomTypeTest, RegisterWithSerde) {
       [](const std::string&) { return std::make_shared<TestCustomType>(); });
   auto testCustomType = TestCustomTypeRegister::VeloxType::get();
 
+  // Serialize and deserialize.
+  auto serializedCustomType = testCustomType->serialize();
+  EXPECT_EQ(testCustomTypeName, serializedCustomType["opaque"]);
+
+  auto deserializedType = Type::create(serializedCustomType);
+  EXPECT_EQ(testCustomType, deserializedType);
+
   // Trying to re-register serialization/deserialization should fail since
   // serialization/deserialization was already registered during type
   // registration.