diff --git a/presto-native-execution/presto_cpp/main/types/TypeSignatureTypeConverter.cpp b/presto-native-execution/presto_cpp/main/types/TypeSignatureTypeConverter.cpp
index cd67e2566d418..5c28d4b3d1cc5 100644
--- a/presto-native-execution/presto_cpp/main/types/TypeSignatureTypeConverter.cpp
+++ b/presto-native-execution/presto_cpp/main/types/TypeSignatureTypeConverter.cpp
@@ -23,6 +23,7 @@
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
 using namespace facebook::velox;
+
 namespace facebook::presto {
 
 TypePtr parseTypeSignature(const std::string& signature) {
@@ -32,9 +33,9 @@ TypePtr parseTypeSignature(const std::string& signature) {
 // static
 TypePtr TypeSignatureTypeConverter::parse(const std::string& text) {
   antlr4::ANTLRInputStream input(text);
-  TypeSignatureLexer lexer(&input);
+  type::TypeSignatureLexer lexer(&input);
   antlr4::CommonTokenStream tokens(&lexer);
-  TypeSignatureParser parser(&tokens);
+  type::TypeSignatureParser parser(&tokens);
 
   parser.setErrorHandler(std::make_shared<antlr4::BailErrorStrategy>());
 
@@ -47,14 +48,63 @@ TypePtr TypeSignatureTypeConverter::parse(const std::string& text) {
   }
 }
 
+namespace {
+
+TypePtr typeFromString(const std::string& typeName) {
+  auto upper = boost::to_upper_copy(typeName);
+
+  if (upper == "UNKNOWN") {
+    return UNKNOWN();
+  }
+
+  if (upper == TIMESTAMP_WITH_TIME_ZONE()->toString()) {
+    return TIMESTAMP_WITH_TIME_ZONE();
+  }
+
+  if (upper == HYPERLOGLOG()->toString()) {
+    return HYPERLOGLOG();
+  }
+
+  if (upper == JSON()->toString()) {
+    return JSON();
+  }
+
+  if (upper == "INT") {
+    upper = "INTEGER";
+  } else if (upper == "DOUBLE PRECISION") {
+    upper = "DOUBLE";
+  }
+
+  if (upper == INTERVAL_DAY_TIME()->toString()) {
+    return INTERVAL_DAY_TIME();
+  }
+
+  if (upper == INTERVAL_YEAR_MONTH()->toString()) {
+    return INTERVAL_YEAR_MONTH();
+  }
+
+  if (upper == DATE()->toString()) {
+    return DATE();
+  }
+
+  return createScalarType(mapNameToTypeKind(upper));
+}
+
+struct NamedType {
+  std::string name;
+  velox::TypePtr type;
+};
+
+} // namespace
+
 antlrcpp::Any TypeSignatureTypeConverter::visitStart(
-    TypeSignatureParser::StartContext* ctx) {
+    type::TypeSignatureParser::StartContext* ctx) {
   NamedType named = visit(ctx->type_spec()).as<NamedType>();
   return named.type;
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitType_spec(
-    TypeSignatureParser::Type_specContext* ctx) {
+    type::TypeSignatureParser::Type_specContext* ctx) {
   if (ctx->named_type()) {
     return visit(ctx->named_type());
   } else {
@@ -63,40 +113,39 @@ antlrcpp::Any TypeSignatureTypeConverter::visitType_spec(
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitNamed_type(
-    TypeSignatureParser::Named_typeContext* ctx) {
+    type::TypeSignatureParser::Named_typeContext* ctx) {
   return NamedType{
       visit(ctx->identifier()).as<std::string>(),
       visit(ctx->type()).as<TypePtr>()};
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitType(
-    TypeSignatureParser::TypeContext* ctx) {
+    type::TypeSignatureParser::TypeContext* ctx) {
   return visitChildren(ctx);
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitSimple_type(
-    TypeSignatureParser::Simple_typeContext* ctx) {
+    type::TypeSignatureParser::Simple_typeContext* ctx) {
   return ctx->WORD() ? typeFromString(ctx->WORD()->getText())
                      : typeFromString(ctx->TYPE_WITH_SPACES()->getText());
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitDecimal_type(
-    TypeSignatureParser::Decimal_typeContext* ctx) {
-  if (ctx->NUMBER().size() != 2) {
-    VELOX_USER_FAIL("Invalid decimal type");
-  }
-  auto precision = ctx->NUMBER(0)->getText();
-  auto scale = ctx->NUMBER(1)->getText();
+    type::TypeSignatureParser::Decimal_typeContext* ctx) {
+  VELOX_USER_CHECK_EQ(2, ctx->NUMBER().size(), "Invalid decimal type");
+
+  const auto precision = ctx->NUMBER(0)->getText();
+  const auto scale = ctx->NUMBER(1)->getText();
   return DECIMAL(std::atoi(precision.c_str()), std::atoi(scale.c_str()));
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitVariable_type(
-    TypeSignatureParser::Variable_typeContext* ctx) {
+    type::TypeSignatureParser::Variable_typeContext* ctx) {
   return typeFromString(ctx->WORD()->getText());
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitType_list(
-    TypeSignatureParser::Type_listContext* ctx) {
+    type::TypeSignatureParser::Type_listContext* ctx) {
   std::vector<NamedType> types;
   for (auto type_spec : ctx->type_spec()) {
     types.emplace_back(visit(type_spec).as<NamedType>());
@@ -105,24 +154,38 @@ antlrcpp::Any TypeSignatureTypeConverter::visitType_list(
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitRow_type(
-    TypeSignatureParser::Row_typeContext* ctx) {
-  return rowFromNamedTypes(
-      visit(ctx->type_list()).as<std::vector<NamedType>>());
+    type::TypeSignatureParser::Row_typeContext* ctx) {
+  const auto namedTypes = visit(ctx->type_list()).as<std::vector<NamedType>>();
+
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  names.reserve(namedTypes.size());
+  types.reserve(namedTypes.size());
+  for (const auto& namedType : namedTypes) {
+    names.push_back(namedType.name);
+    types.push_back(namedType.type);
+  }
+
+  const TypePtr rowType = ROW(std::move(names), std::move(types));
+  return rowType;
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitMap_type(
-    TypeSignatureParser::Map_typeContext* ctx) {
-  return mapFromKeyValueType(
-      visit(ctx->type()[0]).as<TypePtr>(), visit(ctx->type()[1]).as<TypePtr>());
+    type::TypeSignatureParser::Map_typeContext* ctx) {
+  const auto keyType = visit(ctx->type()[0]).as<TypePtr>();
+  const auto valueType = visit(ctx->type()[1]).as<TypePtr>();
+  const TypePtr mapType = MAP(keyType, valueType);
+  return mapType;
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitArray_type(
-    TypeSignatureParser::Array_typeContext* ctx) {
-  return arrayFromType(visit(ctx->type()).as<TypePtr>());
+    type::TypeSignatureParser::Array_typeContext* ctx) {
+  const TypePtr arrayType = ARRAY(visit(ctx->type()).as<TypePtr>());
+  return arrayType;
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitFunction_type(
-    TypeSignatureParser::Function_typeContext* ctx) {
+    type::TypeSignatureParser::Function_typeContext* ctx) {
   const auto numArgs = ctx->type().size() - 1;
 
   std::vector<TypePtr> argumentTypes;
@@ -138,7 +201,7 @@ antlrcpp::Any TypeSignatureTypeConverter::visitFunction_type(
 }
 
 antlrcpp::Any TypeSignatureTypeConverter::visitIdentifier(
-    TypeSignatureParser::IdentifierContext* ctx) {
+    type::TypeSignatureParser::IdentifierContext* ctx) {
   if (ctx->WORD()) {
     return ctx->WORD()->getText();
   } else {
@@ -147,67 +210,4 @@ antlrcpp::Any TypeSignatureTypeConverter::visitIdentifier(
   }
 }
 
-TypePtr typeFromString(const std::string& typeName) {
-  auto upper = boost::to_upper_copy(typeName);
-
-  if (upper == "UNKNOWN") {
-    return UNKNOWN();
-  }
-
-  if (upper == TIMESTAMP_WITH_TIME_ZONE()->toString()) {
-    return TIMESTAMP_WITH_TIME_ZONE();
-  }
-
-  if (upper == HYPERLOGLOG()->toString()) {
-    return HYPERLOGLOG();
-  }
-
-  if (upper == JSON()->toString()) {
-    return JSON();
-  }
-
-  if (upper == "INT") {
-    upper = "INTEGER";
-  } else if (upper == "DOUBLE PRECISION") {
-    upper = "DOUBLE";
-  }
-
-  if (upper == INTERVAL_DAY_TIME()->toString()) {
-    return INTERVAL_DAY_TIME();
-  }
-
-  if (upper == INTERVAL_YEAR_MONTH()->toString()) {
-    return INTERVAL_YEAR_MONTH();
-  }
-
-  if (upper == DATE()->toString()) {
-    return DATE();
-  }
-
-  return createScalarType(mapNameToTypeKind(upper));
-}
-
-TypePtr rowFromNamedTypes(const std::vector<NamedType>& named) {
-  std::vector<std::string> names{};
-  std::transform(
-      named.begin(), named.end(), std::back_inserter(names), [](NamedType v) {
-        return v.name;
-      });
-  std::vector<TypePtr> types{};
-  std::transform(
-      named.begin(), named.end(), std::back_inserter(types), [](NamedType v) {
-        return v.type;
-      });
-
-  return TypeFactory<TypeKind::ROW>::create(std::move(names), std::move(types));
-}
-
-TypePtr mapFromKeyValueType(TypePtr keyType, TypePtr valueType) {
-  return TypeFactory<TypeKind::MAP>::create(keyType, valueType);
-}
-
-TypePtr arrayFromType(TypePtr valueType) {
-  return TypeFactory<TypeKind::ARRAY>::create(valueType);
-}
-
 } // namespace facebook::presto
diff --git a/presto-native-execution/presto_cpp/main/types/TypeSignatureTypeConverter.h b/presto-native-execution/presto_cpp/main/types/TypeSignatureTypeConverter.h
index c23a561b9edce..d48b266ca7406 100644
--- a/presto-native-execution/presto_cpp/main/types/TypeSignatureTypeConverter.h
+++ b/presto-native-execution/presto_cpp/main/types/TypeSignatureTypeConverter.h
@@ -18,53 +18,39 @@
 
 #include "presto_cpp/main/types/antlr/TypeSignatureBaseVisitor.h"
 
-namespace facebook {
-namespace presto {
-using namespace type;
+namespace facebook::presto {
 
-class TypeSignatureTypeConverter : TypeSignatureBaseVisitor {
+class TypeSignatureTypeConverter : type::TypeSignatureBaseVisitor {
+ public:
+  static velox::TypePtr parse(const std::string& text);
+
+ private:
   virtual antlrcpp::Any visitStart(
-      TypeSignatureParser::StartContext* ctx) override;
+      type::TypeSignatureParser::StartContext* ctx) override;
   virtual antlrcpp::Any visitNamed_type(
-      TypeSignatureParser::Named_typeContext* ctx) override;
+      type::TypeSignatureParser::Named_typeContext* ctx) override;
   virtual antlrcpp::Any visitType_spec(
-      TypeSignatureParser::Type_specContext* ctx) override;
+      type::TypeSignatureParser::Type_specContext* ctx) override;
   virtual antlrcpp::Any visitType(
-      TypeSignatureParser::TypeContext* ctx) override;
+      type::TypeSignatureParser::TypeContext* ctx) override;
   virtual antlrcpp::Any visitSimple_type(
-      TypeSignatureParser::Simple_typeContext* ctx) override;
+      type::TypeSignatureParser::Simple_typeContext* ctx) override;
   virtual antlrcpp::Any visitDecimal_type(
-      TypeSignatureParser::Decimal_typeContext* ctx) override;
+      type::TypeSignatureParser::Decimal_typeContext* ctx) override;
   virtual antlrcpp::Any visitVariable_type(
-      TypeSignatureParser::Variable_typeContext* ctx) override;
+      type::TypeSignatureParser::Variable_typeContext* ctx) override;
   virtual antlrcpp::Any visitType_list(
-      TypeSignatureParser::Type_listContext* ctx) override;
+      type::TypeSignatureParser::Type_listContext* ctx) override;
   virtual antlrcpp::Any visitRow_type(
-      TypeSignatureParser::Row_typeContext* ctx) override;
+      type::TypeSignatureParser::Row_typeContext* ctx) override;
   virtual antlrcpp::Any visitMap_type(
-      TypeSignatureParser::Map_typeContext* ctx) override;
+      type::TypeSignatureParser::Map_typeContext* ctx) override;
   virtual antlrcpp::Any visitArray_type(
-      TypeSignatureParser::Array_typeContext* ctx) override;
+      type::TypeSignatureParser::Array_typeContext* ctx) override;
   virtual antlrcpp::Any visitFunction_type(
-      TypeSignatureParser::Function_typeContext* ctx) override;
+      type::TypeSignatureParser::Function_typeContext* ctx) override;
   virtual antlrcpp::Any visitIdentifier(
-      TypeSignatureParser::IdentifierContext* ctx) override;
-
- public:
-  static std::shared_ptr<const velox::Type> parse(const std::string& text);
+      type::TypeSignatureParser::IdentifierContext* ctx) override;
 };
 
-struct NamedType {
-  std::string name;
-  velox::TypePtr type;
-};
-
-velox::TypePtr typeFromString(const std::string& typeName);
-velox::TypePtr rowFromNamedTypes(const std::vector<NamedType>& named);
-velox::TypePtr mapFromKeyValueType(
-    velox::TypePtr keyType,
-    velox::TypePtr valueType);
-velox::TypePtr arrayFromType(velox::TypePtr valueType);
-
-} // namespace presto
-} // namespace facebook
+} // namespace facebook::presto
diff --git a/presto-native-execution/presto_cpp/main/types/tests/TypeSignatureTest.cpp b/presto-native-execution/presto_cpp/main/types/tests/TypeSignatureTest.cpp
index f1f56b805c134..e20d5410dc961 100644
--- a/presto-native-execution/presto_cpp/main/types/tests/TypeSignatureTest.cpp
+++ b/presto-native-execution/presto_cpp/main/types/tests/TypeSignatureTest.cpp
@@ -14,404 +14,193 @@
 #include <gtest/gtest.h>
 
 #include "presto_cpp/main/types/ParseTypeSignature.h"
-#include "presto_cpp/main/types/TypeSignatureTypeConverter.h"
-#include "velox/type/Type.h"
+#include "velox/common/base/tests/GTestUtils.h"
 
-using namespace facebook::presto;
 using namespace facebook::velox;
 
-template <typename... T>
-TypePtr rowSignature(T const&... elements) {
-  std::vector<NamedType> types = {elements...};
-  return rowFromNamedTypes(types);
-}
-
-TypePtr signature(std::string typeName) {
-  return typeFromString(typeName);
-}
-
-NamedType namedParameter(std::string name, TypePtr type) {
-  return NamedType{name, type};
-}
-
-NamedType namedParameter(std::string name, bool _unused, TypePtr type) {
-  return namedParameter(name, type);
-}
-
-NamedType unnamedParameter(TypePtr type) {
-  return NamedType{"", type};
-}
-
-TypePtr varchar() {
-  return typeFromString("VARCHAR");
-}
-
-TypePtr varchar(int size) {
-  return typeFromString("VARCHAR");
-}
-
-TypePtr array(TypePtr type) {
-  return arrayFromType(type);
-}
-TypePtr map(TypePtr key, TypePtr value) {
-  return mapFromKeyValueType(key, value);
-}
-
-#define ASSERT_THROWS_CONTAINS_MESSAGE(statement, exception, message) \
-  try {                                                               \
-    statement FAIL();                                                 \
-  } catch (const exception& err) {                                    \
-    EXPECT_PRED_FORMAT2(testing::IsSubstring, message, err.what());   \
-  }
-
-#define assertRowSignature(input, expected) \
-  ASSERT_EQ(parseTypeSignature(input)->toString(), expected->toString());
-#define assertSignature(input, expected) \
-  ASSERT_EQ(parseTypeSignature(input)->toString(), expected)
-#define assertSignatureFail(input) \
-  ASSERT_ANY_THROW(parseTypeSignature(input)->toString();)
-#define assertEquals(input, expected) \
-  ASSERT_EQ(input->toString(), expected->toString())
-
-// Checks that exception error message contains the given message.
-#define assertRowSignatureContainsThrows(input, expected, exception, message) \
-  ASSERT_THROWS_CONTAINS_MESSAGE(parseTypeSignature(input)->toString();       \
-                                 , exception, message)
+namespace facebook::presto {
+namespace {
 
 class TestTypeSignature : public ::testing::Test {};
 
-TEST_F(TestTypeSignature, sig01) {
-  assertSignature("boolean", "BOOLEAN");
+TEST_F(TestTypeSignature, booleanType) {
+  ASSERT_EQ(*parseTypeSignature("boolean"), *BOOLEAN());
 }
 
-TEST_F(TestTypeSignature, sig02) {
-  assertSignature("varchar", "VARCHAR");
+TEST_F(TestTypeSignature, integerType) {
+  ASSERT_EQ(*parseTypeSignature("int"), *INTEGER());
+  ASSERT_EQ(*parseTypeSignature("integer"), *INTEGER());
 }
 
-TEST_F(TestTypeSignature, sig03) {
-  assertEquals(parseTypeSignature("int"), parseTypeSignature("integer"));
+TEST_F(TestTypeSignature, varcharType) {
+  ASSERT_EQ(*parseTypeSignature("varchar"), *VARCHAR());
 }
 
-TEST_F(TestTypeSignature, sig04) {
-  assertSignature("array(bigint)", "ARRAY<BIGINT>");
+TEST_F(TestTypeSignature, varbinary) {
+  ASSERT_EQ(*parseTypeSignature("varbinary"), *VARBINARY());
 }
 
-TEST_F(TestTypeSignature, sig05) {
-  assertEquals(
-      parseTypeSignature("array(int)"), parseTypeSignature("array(integer)"));
-}
+TEST_F(TestTypeSignature, arrayType) {
+  ASSERT_EQ(*parseTypeSignature("array(bigint)"), *ARRAY(BIGINT()));
 
-TEST_F(TestTypeSignature, sig06) {
-  assertSignature("array(array(bigint))", "ARRAY<ARRAY<BIGINT>>");
-}
+  ASSERT_EQ(*parseTypeSignature("array(int)"), *ARRAY(INTEGER()));
+  ASSERT_EQ(*parseTypeSignature("array(integer)"), *ARRAY(INTEGER()));
 
-TEST_F(TestTypeSignature, sig07) {
-  assertEquals(
-      parseTypeSignature("array(array(int))"),
-      parseTypeSignature("array(array(integer))"));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("array(array(bigint))"), *ARRAY(ARRAY(BIGINT())));
 
-TEST_F(TestTypeSignature, sig08) {
-  assertSignature("map(bigint,bigint)", "MAP<BIGINT,BIGINT>");
+  ASSERT_EQ(*parseTypeSignature("array(array(int))"), *ARRAY(ARRAY(INTEGER())));
 }
 
-TEST_F(TestTypeSignature, sig09) {
-  assertSignature("map(bigint,array(bigint))", "MAP<BIGINT,ARRAY<BIGINT>>");
-}
+TEST_F(TestTypeSignature, mapType) {
+  ASSERT_EQ(
+      *parseTypeSignature("map(bigint,bigint)"), *MAP(BIGINT(), BIGINT()));
 
-TEST_F(TestTypeSignature, sig10) {
-  assertSignature(
-      "map(bigint,map(bigint,map(varchar,bigint)))",
-      "MAP<BIGINT,MAP<BIGINT,MAP<VARCHAR,BIGINT>>>");
-}
+  ASSERT_EQ(
+      *parseTypeSignature("map(bigint,array(bigint))"),
+      *MAP(BIGINT(), ARRAY(BIGINT())));
 
-TEST_F(TestTypeSignature, sig11) {
-  assertSignatureFail("blah()");
+  ASSERT_EQ(
+      *parseTypeSignature("map(bigint,map(bigint,map(varchar,bigint)))"),
+      *MAP(BIGINT(), MAP(BIGINT(), MAP(VARCHAR(), BIGINT()))));
 }
 
-TEST_F(TestTypeSignature, sig12) {
-  assertSignatureFail("array()");
-}
+TEST_F(TestTypeSignature, invalidType) {
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("blah()"), "Failed to parse type [blah()]");
 
-TEST_F(TestTypeSignature, sig13) {
-  assertSignatureFail("map()");
-}
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("array()"), "Failed to parse type [array()]");
 
-TEST_F(TestTypeSignature, sig14) {
-  assertSignatureFail("x");
-}
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("map()"), "Failed to parse type [map()]");
 
-TEST_F(TestTypeSignature, sig16) {
-  // ensure this is not treated as a row type
-  assertSignatureFail("rowxxx(a)");
-}
+  VELOX_ASSERT_THROW(parseTypeSignature("x"), "Failed to parse type [x]");
 
-TEST_F(TestTypeSignature, rowWithNumericFieldName) {
-  assertRowSignature(
-      "row(\"12\" bigint,b bigint,c bigint)",
-      rowSignature(
-          namedParameter("12", false, signature("bigint")),
-          namedParameter("b", false, signature("bigint")),
-          namedParameter("c", false, signature("bigint"))));
+  // Ensure this is not treated as a row type.
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("rowxxx(a)"), "Failed to parse type [rowxxx(a)]");
 }
 
-TEST_F(TestTypeSignature, TestRow01) {
-  assertRowSignature(
-      "row(a bigint,b bigint,c bigint)",
-      rowSignature(
-          namedParameter("a", false, signature("bigint")),
-          namedParameter("b", false, signature("bigint")),
-          namedParameter("c", false, signature("bigint"))));
-}
+TEST_F(TestTypeSignature, rowType) {
+  ASSERT_EQ(
+      *parseTypeSignature("row(a bigint,b varchar,c real)"),
+      *ROW({"a", "b", "c"}, {BIGINT(), VARCHAR(), REAL()}));
 
-TEST_F(TestTypeSignature, TestRow02) {
-  assertRowSignature(
-      "row(a bigint,b array(bigint),c row(a bigint))",
-      rowSignature(
-          namedParameter("a", false, signature("bigint")),
-          namedParameter("b", false, array(signature("bigint"))),
-          namedParameter(
-              "c",
-              false,
-              rowSignature(namedParameter("a", false, signature("bigint"))))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(a bigint,b array(bigint),c row(a bigint))"),
+      *ROW(
+          {"a", "b", "c"},
+          {BIGINT(), ARRAY(BIGINT()), ROW({"a"}, {BIGINT()})}));
 
-// row signature with named fields
-TEST_F(TestTypeSignature, row03) {
-  assertRowSignature(
-      "row(a bigint,b varchar)",
-      rowSignature(
-          namedParameter("a", false, signature("bigint")),
-          namedParameter("b", false, varchar())));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(\"12\" bigint,b bigint,c bigint)"),
+      *ROW({"12", "b", "c"}, {BIGINT(), BIGINT(), BIGINT()}));
 
-TEST_F(TestTypeSignature, row04) {
-  // Wondering about this test of '_varchar' ??
-  // assertRowSignature(
-  //        "row(__a__ bigint,_b@_: _varchar)",
-  //        rowSignature(namedParameter("__a__", false, signature("bigint")),
-  //        namedParameter("_b@_:", false, signature("_varchar"))));
-}
-
-TEST_F(TestTypeSignature, row05) {
-  assertRowSignature(
-      "row(a bigint,b array(bigint),c row(a bigint))",
-      rowSignature(
-          namedParameter("a", false, signature("bigint")),
-          namedParameter("b", false, array(signature("bigint"))),
-          namedParameter(
-              "c",
-              false,
-              rowSignature(namedParameter("a", false, signature("bigint"))))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(a varchar(10),b row(a bigint))"),
+      *ROW({"a", "b"}, {VARCHAR(), ROW({"a"}, {BIGINT()})}));
 
-TEST_F(TestTypeSignature, row06) {
-  assertRowSignature(
-      "row(a varchar(10),b row(a bigint))",
-      rowSignature(
-          namedParameter("a", false, varchar(10)),
-          namedParameter(
-              "b",
-              false,
-              rowSignature(namedParameter("a", false, signature("bigint"))))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("array(row(col0 bigint,col1 double))"),
+      *ARRAY(ROW({"col0", "col1"}, {BIGINT(), DOUBLE()})));
 
-TEST_F(TestTypeSignature, row07) {
-  assertRowSignature(
-      "array(row(col0 bigint,col1 double))",
-      array(rowSignature(
-          namedParameter("col0", false, signature("bigint")),
-          namedParameter("col1", false, signature("double")))));
-}
-
-TEST_F(TestTypeSignature, row08) {
-  assertRowSignature(
-      "row(col0 array(row(col0 bigint,col1 double)))",
-      rowSignature(namedParameter(
-          "col0",
-          false,
-          array(rowSignature(
-              namedParameter("col0", false, signature("bigint")),
-              namedParameter("col1", false, signature("double")))))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(col0 array(row(col0 bigint,col1 double)))"),
+      *ROW({"col0"}, {ARRAY(ROW({"col0", "col1"}, {BIGINT(), DOUBLE()}))}));
 
-TEST_F(TestTypeSignature, row09) {
-  // row with mixed fields
-  assertRowSignature(
-      "row(bigint,varchar)",
-      rowSignature(
-          unnamedParameter(signature("bigint")), unnamedParameter(varchar())));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(bigint,varchar)"), *ROW({BIGINT(), VARCHAR()}));
 
-TEST_F(TestTypeSignature, row10) {
-  assertRowSignature(
-      "row(bigint,array(bigint),row(a bigint))",
-      rowSignature(
-          unnamedParameter(signature("bigint")),
-          unnamedParameter(array(signature("bigint"))),
-          unnamedParameter(
-              rowSignature(namedParameter("a", false, signature("bigint"))))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(bigint,array(bigint),row(a bigint))"),
+      *ROW({BIGINT(), ARRAY(BIGINT()), ROW({"a"}, {BIGINT()})}));
 
-TEST_F(TestTypeSignature, row11) {
-  assertRowSignature(
-      "row(varchar(10),b row(bigint))",
-      rowSignature(
-          unnamedParameter(varchar(10)),
-          namedParameter(
-              "b",
-              false,
-              rowSignature(unnamedParameter(signature("bigint"))))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(varchar(10),b row(bigint))"),
+      *ROW({"", "b"}, {VARCHAR(), ROW({BIGINT()})}));
 
-TEST_F(TestTypeSignature, row12) {
-  assertRowSignature(
-      "array(row(col0 bigint,double))",
-      array(rowSignature(
-          namedParameter("col0", false, signature("bigint")),
-          unnamedParameter(signature("double")))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("array(row(col0 bigint,double))"),
+      *ARRAY(ROW({"col0", ""}, {BIGINT(), DOUBLE()})));
 
-TEST_F(TestTypeSignature, row13) {
-  assertRowSignature(
-      "row(col0 array(row(bigint,double)))",
-      rowSignature(namedParameter(
-          "col0",
-          false,
-          array(rowSignature(
-              unnamedParameter(signature("bigint")),
-              unnamedParameter(signature("double")))))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(col0 array(row(bigint,double)))"),
+      *ROW({"col0"}, {ARRAY(ROW({BIGINT(), DOUBLE()}))}));
 
-TEST_F(TestTypeSignature, row14) {
-  assertRowSignature(
-      "row(double double precision)",
-      rowSignature(
-          namedParameter("double", false, signature("double precision"))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(double double precision)"),
+      *ROW({"double"}, {DOUBLE()}));
 
-TEST_F(TestTypeSignature, row15) {
-  assertRowSignature(
-      "row(double precision)",
-      rowSignature(unnamedParameter(signature("double precision"))));
-}
+  ASSERT_EQ(*parseTypeSignature("row(double precision)"), *ROW({DOUBLE()}));
 
-TEST_F(TestTypeSignature, row16) {
-  // preserve base name case
-  assertRowSignature(
-      "RoW(a bigint,b varchar)",
-      rowSignature(
-          namedParameter("a", false, signature("bigint")),
-          namedParameter("b", false, varchar())));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("RoW(a bigint,b varchar)"),
+      *ROW({"a", "b"}, {BIGINT(), VARCHAR()}));
 
-TEST_F(TestTypeSignature, row17) {
-  // field type canonicalization
-  assertEquals(
-      parseTypeSignature("row(col iNt)"),
-      parseTypeSignature("row(col integer)"));
+  // Field type canonicalization.
+  ASSERT_EQ(*parseTypeSignature("row(col iNt)"), *ROW({"col"}, {INTEGER()}));
 }
 
-// TEST_F(TestTypeSignature, row18) {
-// assertEquals(parseTypeSignature("row(a Int(p1))"), parseTypeSignature("row(a
-// integer(p1))"));
-
-// signature with invalid type
-// assertRowSignature(
-//        "row(\"time\" with time zone)",
-//        rowSignature(namedParameter("time", true, signature("with time
-//        zone"))));
-//}
-
-// The TestSpacesXX tests all throw failures.  The parser succeeds by the
-// resulting types are not supported by Koski.
-//
-TEST_F(TestTypeSignature, spaces01) {
-  // named fields of types with spaces
-  assertRowSignatureContainsThrows(
-      "row(time time with time zone)",
-      rowSignature(
-          namedParameter("time", false, signature("time with time zone"))),
-      VeloxUserError,
+TEST_F(TestTypeSignature, typesWithSpaces) {
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("row(time time with time zone)"),
       "Specified element is not found : TIME WITH TIME ZONE");
-}
 
-TEST_F(TestTypeSignature, spaces04) {
-  assertRowSignature(
-      "row(interval interval year to month)",
-      rowSignature(namedParameter(
-          "interval", false, signature("interval year to month"))));
-}
+  ASSERT_EQ(
+      *parseTypeSignature("row(double double precision)"),
+      *ROW({"double"}, {DOUBLE()}));
 
-TEST_F(TestTypeSignature, spaces05) {
-  assertRowSignature(
-      "row(double double precision)",
-      rowSignature(
-          namedParameter("double", false, signature("double precision"))));
-}
-
-TEST_F(TestTypeSignature, spaces06) {
-  // unnamed fields of types with spaces
-  assertRowSignatureContainsThrows(
-      "row(time with time zone)",
-      rowSignature(unnamedParameter(signature("time with time zone"))),
-      VeloxUserError,
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("row(time with time zone)"),
       "Specified element is not found : TIME WITH TIME ZONE");
-}
-
-TEST_F(TestTypeSignature, spaces09) {
-  assertRowSignature(
-      "row(interval year to month)",
-      rowSignature(unnamedParameter(signature("interval year to month"))));
-}
 
-TEST_F(TestTypeSignature, spaces10) {
-  assertRowSignature(
-      "row(double precision)",
-      rowSignature(unnamedParameter(signature("double precision"))));
-}
+  ASSERT_EQ(*parseTypeSignature("row(double precision)"), *ROW({DOUBLE()}));
 
-TEST_F(TestTypeSignature, spaces11) {
-  assertRowSignatureContainsThrows(
-      "row(array(time with time zone))",
-      rowSignature(unnamedParameter(array(signature("time with time zone")))),
-      VeloxUserError,
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("row(array(time with time zone))"),
       "Specified element is not found : TIME WITH TIME ZONE");
-}
 
-TEST_F(TestTypeSignature, spaces13) {
   // quoted field names
-  assertRowSignatureContainsThrows(
-      "row(\"time with time zone\" time with time zone,\"double\" double)",
-      rowSignature(
-          namedParameter(
-              "time with time zone", true, signature("time with time zone")),
-          namedParameter("double", true, signature("double"))),
-      VeloxUserError,
+  VELOX_ASSERT_THROW(
+      parseTypeSignature(
+          "row(\"time with time zone\" time with time zone,\"double\" double)"),
       "Specified element is not found : TIME WITH TIME ZONE");
 }
 
+TEST_F(TestTypeSignature, intervalYearToMonthType) {
+  ASSERT_EQ(
+      *parseTypeSignature("row(interval interval year to month)"),
+      *ROW({"interval"}, {INTERVAL_YEAR_MONTH()}));
+
+  ASSERT_EQ(
+      *parseTypeSignature("row(interval year to month)"),
+      *ROW({INTERVAL_YEAR_MONTH()}));
+}
+
 TEST_F(TestTypeSignature, functionType) {
-  assertSignature(
-      "function(bigint,bigint,bigint)", "FUNCTION<BIGINT, BIGINT, BIGINT>");
-  assertSignature(
-      "function(bigint,array(varchar),varchar)",
-      "FUNCTION<BIGINT, ARRAY<VARCHAR>, VARCHAR>");
+  ASSERT_EQ(
+      *parseTypeSignature("function(bigint,bigint,bigint)"),
+      *FUNCTION({BIGINT(), BIGINT()}, BIGINT()));
+  ASSERT_EQ(
+      *parseTypeSignature("function(bigint,array(varchar),varchar)"),
+      *FUNCTION({BIGINT(), ARRAY(VARCHAR())}, VARCHAR()));
 }
 
 TEST_F(TestTypeSignature, decimalType) {
-  assertSignature("decimal(10, 5)", "DECIMAL(10, 5)");
-  assertSignature("decimal(20,10)", "DECIMAL(20, 10)");
-  ASSERT_THROWS_CONTAINS_MESSAGE(
-      parseTypeSignature("decimal");
-      , VeloxUserError, "Failed to parse type [decimal]");
-  ASSERT_THROWS_CONTAINS_MESSAGE(
-      parseTypeSignature("decimal()");
-      , VeloxUserError, "Failed to parse type [decimal()]");
-  ASSERT_THROWS_CONTAINS_MESSAGE(
-      parseTypeSignature("decimal(20)");
-      , VeloxUserError, "Failed to parse type [decimal(20)]");
-  ASSERT_THROWS_CONTAINS_MESSAGE(
-      parseTypeSignature("decimal(, 20)");
-      , VeloxUserError, "Failed to parse type [decimal(, 20)]");
-}
+  ASSERT_EQ(*parseTypeSignature("decimal(10, 5)"), *DECIMAL(10, 5));
+  ASSERT_EQ(*parseTypeSignature("decimal(20,10)"), *DECIMAL(20, 10));
+
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("decimal"), "Failed to parse type [decimal]");
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("decimal()"), "Failed to parse type [decimal()]");
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("decimal(20)"), "Failed to parse type [decimal(20)]");
+  VELOX_ASSERT_THROW(
+      parseTypeSignature("decimal(, 20)"),
+      "Failed to parse type [decimal(, 20)]");
+}
+
+} // namespace
+} // namespace facebook::presto