From ad57e3b23852a34c362000e507c0fbe5d29351bf Mon Sep 17 00:00:00 2001
From: Alper Yoney <alperyoney@meta.com>
Date: Tue, 28 Jan 2025 15:17:59 -0800
Subject: [PATCH] Replace same_tag with std::is_same_v

Summary: Replace `test::same_tag<>` with `std::is_same_v<>`

Reviewed By: Mizuchi

Differential Revision: D68788509

fbshipit-source-id: 349ce7237ac8faa7d9e0bfc350face95ab263831
---
 .../thrift/lib/cpp2/type/NativeTypeTest.cpp   |  42 ++---
 .../src/thrift/lib/cpp2/type/TagTest.cpp      | 103 ++++++------
 .../thrift/src/thrift/lib/cpp2/type/Testing.h |  10 --
 .../src/thrift/test/reflection/FieldsTest.cpp | 157 ++++++++++--------
 4 files changed, 167 insertions(+), 145 deletions(-)

diff --git a/third-party/thrift/src/thrift/lib/cpp2/type/NativeTypeTest.cpp b/third-party/thrift/src/thrift/lib/cpp2/type/NativeTypeTest.cpp
index 1ccc573d98c8b..634feae03c426 100644
--- a/third-party/thrift/src/thrift/lib/cpp2/type/NativeTypeTest.cpp
+++ b/third-party/thrift/src/thrift/lib/cpp2/type/NativeTypeTest.cpp
@@ -41,17 +41,17 @@ TEST(NativeTypeTest, UndefinedOverloading) {
 
 TEST(NativeTypeTest, Void) {
   static_assert(std::is_same_v<void, native_type<void_t>>);
-  static_assert(test::same_tag<void_t, infer_tag<void>>);
-  static_assert(test::same_tag<void_t, infer_tag<std::nullptr_t>>);
+  static_assert(std::is_same_v<void_t, infer_tag<void>>);
+  static_assert(std::is_same_v<void_t, infer_tag<std::nullptr_t>>);
 }
 
 TEST(NativeTypeTest, Bool) {
   static_assert(std::is_same_v<bool, native_type<bool_t>>);
-  static_assert(test::same_tag<bool_t, infer_tag<bool>>);
+  static_assert(std::is_same_v<bool_t, infer_tag<bool>>);
 }
 
 TEST(InferTagTest, Tag) {
-  static_assert(test::same_tag<byte_t, infer_tag<byte_t>>);
+  static_assert(std::is_same_v<byte_t, infer_tag<byte_t>>);
 }
 
 TEST(InferTagTest, Integer) {
@@ -59,14 +59,14 @@ TEST(InferTagTest, Integer) {
   static_assert(std::is_same_v<int16_t, native_type<i16_t>>);
   static_assert(std::is_same_v<int32_t, native_type<i32_t>>);
   static_assert(std::is_same_v<int64_t, native_type<i64_t>>);
-  static_assert(test::same_tag<byte_t, infer_tag<int8_t>>);
-  static_assert(test::same_tag<i16_t, infer_tag<int16_t>>);
-  static_assert(test::same_tag<i32_t, infer_tag<int32_t>>);
-  static_assert(test::same_tag<i64_t, infer_tag<int64_t>>);
-  static_assert(test::same_tag<cpp_type<uint8_t, byte_t>, infer_tag<uint8_t>>);
-  static_assert(test::same_tag<cpp_type<uint16_t, i16_t>, infer_tag<uint16_t>>);
-  static_assert(test::same_tag<cpp_type<uint32_t, i32_t>, infer_tag<uint32_t>>);
-  static_assert(test::same_tag<cpp_type<uint64_t, i64_t>, infer_tag<uint64_t>>);
+  static_assert(std::is_same_v<byte_t, infer_tag<int8_t>>);
+  static_assert(std::is_same_v<i16_t, infer_tag<int16_t>>);
+  static_assert(std::is_same_v<i32_t, infer_tag<int32_t>>);
+  static_assert(std::is_same_v<i64_t, infer_tag<int64_t>>);
+  static_assert(std::is_same_v<cpp_type<uint8_t, byte_t>, infer_tag<uint8_t>>);
+  static_assert(std::is_same_v<cpp_type<uint16_t, i16_t>, infer_tag<uint16_t>>);
+  static_assert(std::is_same_v<cpp_type<uint32_t, i32_t>, infer_tag<uint32_t>>);
+  static_assert(std::is_same_v<cpp_type<uint64_t, i64_t>, infer_tag<uint64_t>>);
 
   static_assert(type::is_a_v<infer_tag<char>, byte_t>);
   static_assert(type::is_a_v<infer_tag<signed char>, byte_t>);
@@ -86,8 +86,8 @@ TEST(InferTagTest, Integer) {
 TEST(InferTagTest, Floating) {
   static_assert(std::is_same_v<float, native_type<float_t>>);
   static_assert(std::is_same_v<double, native_type<double_t>>);
-  static_assert(test::same_tag<float_t, infer_tag<float>>);
-  static_assert(test::same_tag<double_t, infer_tag<double>>);
+  static_assert(std::is_same_v<float_t, infer_tag<float>>);
+  static_assert(std::is_same_v<double_t, infer_tag<double>>);
 }
 
 TEST(InferTagTest, Strings) {
@@ -99,16 +99,16 @@ TEST(InferTagTest, Strings) {
 
 TEST(InferTagTest, Containers) {
   static_assert(
-      test::same_tag<native_type<list<i32_t>>, std::vector<std::int32_t>>);
+      std::is_same_v<native_type<list<i32_t>>, std::vector<std::int32_t>>);
   static_assert(
-      test::same_tag<list<i32_t>, infer_tag<std::vector<std::int32_t>>>);
+      std::is_same_v<list<i32_t>, infer_tag<std::vector<std::int32_t>>>);
   static_assert(
-      test::same_tag<native_type<set<i32_t>>, std::set<std::int32_t>>);
-  static_assert(test::same_tag<set<i32_t>, infer_tag<std::set<std::int32_t>>>);
-  static_assert(test::same_tag<
+      std::is_same_v<native_type<set<i32_t>>, std::set<std::int32_t>>);
+  static_assert(std::is_same_v<set<i32_t>, infer_tag<std::set<std::int32_t>>>);
+  static_assert(std::is_same_v<
                 native_type<map<i32_t, bool_t>>,
                 std::map<std::int32_t, bool>>);
-  static_assert(test::same_tag<
+  static_assert(std::is_same_v<
                 map<i32_t, bool_t>,
                 infer_tag<std::map<std::int32_t, bool>>>);
 }
@@ -116,7 +116,7 @@ TEST(InferTagTest, Containers) {
 TEST(InferTagTest, Wrap) {
   struct FooStruct {};
   struct Foo : detail::Wrap<FooStruct, struct_t<FooStruct>> {};
-  static_assert(test::same_tag<
+  static_assert(std::is_same_v<
                 infer_tag<Foo>,
                 adapted<InlineAdapter<Foo>, struct_t<FooStruct>>>);
 }
diff --git a/third-party/thrift/src/thrift/lib/cpp2/type/TagTest.cpp b/third-party/thrift/src/thrift/lib/cpp2/type/TagTest.cpp
index e9e85a2cb667b..85de1a6080d42 100644
--- a/third-party/thrift/src/thrift/lib/cpp2/type/TagTest.cpp
+++ b/third-party/thrift/src/thrift/lib/cpp2/type/TagTest.cpp
@@ -18,6 +18,7 @@
 
 #include <list>
 #include <map>
+#include <type_traits>
 #include <unordered_set>
 
 #include <folly/portability/GTest.h>
@@ -77,96 +78,104 @@ cpp_type<set<Specialized>, std::unordered_set<int>> testOverload(
 map<Specialized, Specialized> testOverload(map<Specialized, Specialized>);
 
 namespace {
-using test::same_tag;
 using test::TestAdapter;
 
 // Test that type tags can be used to find an overload in ~constant time
 // by the compiler.
-static_assert(same_tag<all_c, decltype(testOverload(primitive_c{}))>);
-static_assert(same_tag<void_t, decltype(testOverload(void_t{}))>);
-static_assert(same_tag<integral_c, decltype(testOverload(bool_t{}))>);
-static_assert(same_tag<byte_t, decltype(testOverload(byte_t{}))>);
-static_assert(same_tag<integral_c, decltype(testOverload(i16_t{}))>);
-static_assert(same_tag<i32_t, decltype(testOverload(i32_t{}))>);
-static_assert(same_tag<i64_t, decltype(testOverload(i64_t{}))>);
-static_assert(same_tag<floating_point_c, decltype(testOverload(float_t{}))>);
-static_assert(same_tag<double_t, decltype(testOverload(double_t{}))>);
-static_assert(same_tag<string_t, decltype(testOverload(string_t{}))>);
-static_assert(same_tag<string_c, decltype(testOverload(binary_t{}))>);
-
-static_assert(same_tag<enum_c, decltype(testOverload(enum_c{}))>);
-static_assert(same_tag<enum_c, decltype(testOverload(enum_t<General>{}))>);
-static_assert(same_tag<
+static_assert(std::is_same_v<all_c, decltype(testOverload(primitive_c{}))>);
+static_assert(std::is_same_v<void_t, decltype(testOverload(void_t{}))>);
+static_assert(std::is_same_v<integral_c, decltype(testOverload(bool_t{}))>);
+static_assert(std::is_same_v<byte_t, decltype(testOverload(byte_t{}))>);
+static_assert(std::is_same_v<integral_c, decltype(testOverload(i16_t{}))>);
+static_assert(std::is_same_v<i32_t, decltype(testOverload(i32_t{}))>);
+static_assert(std::is_same_v<i64_t, decltype(testOverload(i64_t{}))>);
+static_assert(
+    std::is_same_v<floating_point_c, decltype(testOverload(float_t{}))>);
+static_assert(std::is_same_v<double_t, decltype(testOverload(double_t{}))>);
+static_assert(std::is_same_v<string_t, decltype(testOverload(string_t{}))>);
+static_assert(std::is_same_v<string_c, decltype(testOverload(binary_t{}))>);
+
+static_assert(std::is_same_v<enum_c, decltype(testOverload(enum_c{}))>);
+static_assert(
+    std::is_same_v<enum_c, decltype(testOverload(enum_t<General>{}))>);
+static_assert(std::is_same_v<
               enum_t<Specialized>,
               decltype(testOverload(enum_t<Specialized>{}))>);
 
-static_assert(same_tag<struct_c, decltype(testOverload(struct_c{}))>);
-static_assert(same_tag<struct_c, decltype(testOverload(struct_t<General>{}))>);
-static_assert(same_tag<
+static_assert(std::is_same_v<struct_c, decltype(testOverload(struct_c{}))>);
+static_assert(
+    std::is_same_v<struct_c, decltype(testOverload(struct_t<General>{}))>);
+static_assert(std::is_same_v<
               struct_t<Specialized>,
               decltype(testOverload(struct_t<Specialized>{}))>);
 
-static_assert(same_tag<structured_c, decltype(testOverload(union_c{}))>);
+static_assert(std::is_same_v<structured_c, decltype(testOverload(union_c{}))>);
 static_assert(
-    same_tag<structured_c, decltype(testOverload(union_t<General>{}))>);
-static_assert(same_tag<
+    std::is_same_v<structured_c, decltype(testOverload(union_t<General>{}))>);
+static_assert(std::is_same_v<
               union_t<Specialized>,
               decltype(testOverload(union_t<Specialized>{}))>);
 
-static_assert(same_tag<struct_except_c, decltype(testOverload(exception_c{}))>);
 static_assert(
-    same_tag<struct_except_c, decltype(testOverload(exception_t<General>{}))>);
-static_assert(same_tag<
+    std::is_same_v<struct_except_c, decltype(testOverload(exception_c{}))>);
+static_assert(std::is_same_v<
+              struct_except_c,
+              decltype(testOverload(exception_t<General>{}))>);
+static_assert(std::is_same_v<
               exception_t<Specialized>,
               decltype(testOverload(exception_t<Specialized>{}))>);
 
-static_assert(same_tag<list_c, decltype(testOverload(list_c{}))>);
-static_assert(same_tag<list_c, decltype(testOverload(list<void_t>{}))>);
-static_assert(same_tag<
+static_assert(std::is_same_v<list_c, decltype(testOverload(list_c{}))>);
+static_assert(std::is_same_v<list_c, decltype(testOverload(list<void_t>{}))>);
+static_assert(std::is_same_v<
               cpp_type<list<Specialized>, std::list<Specialized>>,
               decltype(testOverload(
                   cpp_type<list<Specialized>, std::list<Specialized>>{}))>);
-static_assert(same_tag<
+static_assert(std::is_same_v<
               cpp_type<list<Specialized>, std::list<Specialized>>,
               decltype(testOverload(
                   cpp_type<list<Specialized>, std::list<Specialized>>{}))>);
 
-static_assert(same_tag<container_c, decltype(testOverload(set_c{}))>);
-static_assert(same_tag<container_c, decltype(testOverload(set<void_t>{}))>);
+static_assert(std::is_same_v<container_c, decltype(testOverload(set_c{}))>);
 static_assert(
-    same_tag<container_c, decltype(testOverload(set<Specialized>{}))>);
-static_assert(same_tag<
+    std::is_same_v<container_c, decltype(testOverload(set<void_t>{}))>);
+static_assert(
+    std::is_same_v<container_c, decltype(testOverload(set<Specialized>{}))>);
+static_assert(std::is_same_v<
               cpp_type<set<Specialized>, std::unordered_set<int>>,
               decltype(testOverload(
                   cpp_type<set<Specialized>, std::unordered_set<int>>{}))>);
 
-static_assert(same_tag<map_c, decltype(testOverload(map_c{}))>);
-static_assert(same_tag<map_c, decltype(testOverload(map<void_t, void_t>{}))>);
+static_assert(std::is_same_v<map_c, decltype(testOverload(map_c{}))>);
+static_assert(
+    std::is_same_v<map_c, decltype(testOverload(map<void_t, void_t>{}))>);
 static_assert(
-    same_tag<map_c, decltype(testOverload(map<Specialized, void_t>{}))>);
+    std::is_same_v<map_c, decltype(testOverload(map<Specialized, void_t>{}))>);
 static_assert(
-    same_tag<map_c, decltype(testOverload(map<void_t, Specialized>{}))>);
-static_assert(same_tag<
+    std::is_same_v<map_c, decltype(testOverload(map<void_t, Specialized>{}))>);
+static_assert(std::is_same_v<
               map<Specialized, Specialized>,
               decltype(testOverload(map<Specialized, Specialized>{}))>);
 
 // Adapted types are convertable to the underlying tag.
-static_assert(
-    same_tag<void_t, decltype(testOverload(adapted<TestAdapter, void_t>{}))>);
-static_assert(same_tag<
+static_assert(std::is_same_v<
+              void_t,
+              decltype(testOverload(adapted<TestAdapter, void_t>{}))>);
+static_assert(std::is_same_v<
               list_c,
               decltype(testOverload(adapted<TestAdapter, list<enum_c>>{}))>);
 // CppType types are convertable to the underlying tag.
-static_assert(
-    same_tag<void_t, decltype(testOverload(cpp_type<TestAdapter, void_t>{}))>);
-static_assert(same_tag<
+static_assert(std::is_same_v<
+              void_t,
+              decltype(testOverload(cpp_type<TestAdapter, void_t>{}))>);
+static_assert(std::is_same_v<
               list_c,
               decltype(testOverload(cpp_type<TestAdapter, list<enum_c>>{}))>);
 
-static_assert(same_tag<service_c, decltype(testOverload(service_c{}))>);
+static_assert(std::is_same_v<service_c, decltype(testOverload(service_c{}))>);
 static_assert(
-    same_tag<service_c, decltype(testOverload(service_t<General>{}))>);
-static_assert(same_tag<
+    std::is_same_v<service_c, decltype(testOverload(service_t<General>{}))>);
+static_assert(std::is_same_v<
               service_t<Specialized>,
               decltype(testOverload(service_t<Specialized>{}))>);
 
diff --git a/third-party/thrift/src/thrift/lib/cpp2/type/Testing.h b/third-party/thrift/src/thrift/lib/cpp2/type/Testing.h
index 033412eb4f81e..1456b6a3d5083 100644
--- a/third-party/thrift/src/thrift/lib/cpp2/type/Testing.h
+++ b/third-party/thrift/src/thrift/lib/cpp2/type/Testing.h
@@ -29,16 +29,6 @@
 
 namespace apache::thrift::test {
 
-// Helper to check if the tags matches.
-// For example:
-//   static_assert(same_tag<bool_t, void_t>);
-// Will produce an error message similar to:
-//   static assertion failed due to requirement
-//   test::same_tag<apache::thrift::type::bool_t, apache::thrift::type::void_t>
-//   static_assert(test::same_tag<bool_t, void_t>);
-template <typename Expected, typename Actual>
-constexpr bool same_tag = std::is_same_v<Expected, Actual>;
-
 template <typename T>
 struct TestValue {
   T value;
diff --git a/third-party/thrift/src/thrift/test/reflection/FieldsTest.cpp b/third-party/thrift/src/thrift/test/reflection/FieldsTest.cpp
index ef37444680037..4511506f12832 100644
--- a/third-party/thrift/src/thrift/test/reflection/FieldsTest.cpp
+++ b/third-party/thrift/src/thrift/test/reflection/FieldsTest.cpp
@@ -40,15 +40,17 @@ TEST(FieldsTest, Get) {
   EXPECT_EQ((op::get<field_id<2>, Struct>(s)), 10);
   op::get<field_id<2>, Struct>(s) = 20;
   EXPECT_EQ(*s.fieldA(), 20);
-  test::
-      same_tag<decltype(s.fieldA()), decltype(op::get<field_id<2>, Struct>(s))>;
+  static_assert(std::is_same_v<
+                decltype(s.fieldA()),
+                decltype(op::get<field_id<2>, Struct>(s))>);
 
   s.fieldE()->ui_ref() = 10;
   EXPECT_EQ((op::get<field_id<5>, Struct>(s)->ui_ref()), 10);
   op::get<field_id<5>, Struct>(s)->us_ref() = "20";
   EXPECT_EQ(s.fieldE()->us_ref(), "20");
-  test::
-      same_tag<decltype(s.fieldE()), decltype(op::get<field_id<5>, Struct>(s))>;
+  static_assert(std::is_same_v<
+                decltype(s.fieldE()),
+                decltype(op::get<field_id<5>, Struct>(s))>);
 }
 
 TEST(FieldsTest, field_id_by_ordinal) {
@@ -64,8 +66,9 @@ TEST(UnionFieldsTest, Get) {
   u.ui_ref() = 10;
   EXPECT_EQ((op::get<field_id<1>, Union>(u)), 10);
   EXPECT_THROW((*op::get<field_id<2>, Union>(u)), bad_field_access);
-  test::
-      same_tag<decltype(u.ui_ref()), decltype(op::get<field_id<1>, Union>(u))>;
+  static_assert(std::is_same_v<
+                decltype(u.ui_ref()),
+                decltype(op::get<field_id<1>, Union>(u))>);
   EXPECT_EQ(&(*op::get<field_id<1>, Union>(u)), &*u.ui_ref());
 
   op::get<field_id<1>, Union>(u) = 20;
@@ -74,8 +77,9 @@ TEST(UnionFieldsTest, Get) {
 
   u.us_ref() = "foo";
   EXPECT_EQ((*op::get<field_id<3>, Union>(u)), "foo");
-  test::
-      same_tag<decltype(u.us_ref()), decltype(op::get<field_id<3>, Union>(u))>;
+  static_assert(std::is_same_v<
+                decltype(u.us_ref()),
+                decltype(op::get<field_id<3>, Union>(u))>);
   EXPECT_THROW((*op::get<field_id<1>, Union>(u)), bad_field_access);
 }
 
@@ -89,55 +93,60 @@ template <
     class FieldTag>
 void checkField(const char* identName) {
   if constexpr (Ordinal::value != Ordinal{}) {
-    test::same_tag<Id, private_access::field_id<Struct, Ordinal>>;
+    static_assert(
+        std::is_same_v<Id, private_access::field_id<Struct, Ordinal>>);
   }
-  test::same_tag<TypeTag, private_access::type_tag<Struct, Ordinal>>;
-  test::same_tag<Ident, private_access::ident<Struct, Ordinal>>;
-  test::same_tag<Ordinal, private_access::ordinal<Struct, Id>>;
-  test::same_tag<Ordinal, private_access::ordinal<Struct, Ident>>;
+  static_assert(
+      std::is_same_v<TypeTag, private_access::type_tag<Struct, Ordinal>>);
+  static_assert(std::is_same_v<Ident, private_access::ident<Struct, Ordinal>>);
+  static_assert(std::is_same_v<Ordinal, private_access::ordinal<Struct, Id>>);
+  static_assert(
+      std::is_same_v<Ordinal, private_access::ordinal<Struct, Ident>>);
 
   if constexpr (is_type_tag_unique) {
-    test::same_tag<Ordinal, private_access::ordinal<Struct, TypeTag>>;
+    static_assert(
+        std::is_same_v<Ordinal, private_access::ordinal<Struct, TypeTag>>);
   }
 
-  test::same_tag<op::get_ordinal<Struct, Ordinal>, Ordinal>;
-  test::same_tag<op::get_field_id<Struct, Ordinal>, Id>;
-  test::same_tag<op::get_type_tag<Struct, Ordinal>, TypeTag>;
-  test::same_tag<op::get_ident<Struct, Ordinal>, Ident>;
-  test::same_tag<op::get_field_tag<Struct, Ordinal>, FieldTag>;
+  static_assert(std::is_same_v<op::get_ordinal<Struct, Ordinal>, Ordinal>);
+  static_assert(std::is_same_v<op::get_field_id<Struct, Ordinal>, Id>);
+  static_assert(std::is_same_v<op::get_type_tag<Struct, Ordinal>, TypeTag>);
+  static_assert(std::is_same_v<op::get_ident<Struct, Ordinal>, Ident>);
+  static_assert(std::is_same_v<op::get_field_tag<Struct, Ordinal>, FieldTag>);
   EXPECT_EQ((op::get_name_v<Struct, Ordinal>), identName);
 
-  test::same_tag<op::get_ordinal<Struct, Id>, Ordinal>;
-  test::same_tag<op::get_field_id<Struct, Id>, Id>;
-  test::same_tag<op::get_type_tag<Struct, Id>, TypeTag>;
-  test::same_tag<op::get_ident<Struct, Id>, Ident>;
-  test::same_tag<op::get_field_tag<Struct, Id>, FieldTag>;
+  static_assert(std::is_same_v<op::get_ordinal<Struct, Id>, Ordinal>);
+  static_assert(std::is_same_v<op::get_field_id<Struct, Id>, Id>);
+  static_assert(std::is_same_v<op::get_type_tag<Struct, Id>, TypeTag>);
+  static_assert(std::is_same_v<op::get_ident<Struct, Id>, Ident>);
+  static_assert(std::is_same_v<op::get_field_tag<Struct, Id>, FieldTag>);
   EXPECT_EQ((op::get_name_v<Struct, Id>), identName);
 
   if constexpr (is_type_tag_unique && !std::is_void_v<TypeTag>) {
-    test::same_tag<op::get_ordinal<Struct, TypeTag>, Ordinal>;
-    test::same_tag<op::get_field_id<Struct, TypeTag>, Id>;
-    test::same_tag<op::get_type_tag<Struct, TypeTag>, TypeTag>;
-    test::same_tag<op::get_ident<Struct, TypeTag>, Ident>;
-    test::same_tag<op::get_field_tag<Struct, TypeTag>, FieldTag>;
+    static_assert(std::is_same_v<op::get_ordinal<Struct, TypeTag>, Ordinal>);
+    static_assert(std::is_same_v<op::get_field_id<Struct, TypeTag>, Id>);
+    static_assert(std::is_same_v<op::get_type_tag<Struct, TypeTag>, TypeTag>);
+    static_assert(std::is_same_v<op::get_ident<Struct, TypeTag>, Ident>);
+    static_assert(std::is_same_v<op::get_field_tag<Struct, TypeTag>, FieldTag>);
     EXPECT_EQ((op::get_name_v<Struct, TypeTag>), identName);
   }
 
   if constexpr (!std::is_void_v<Ident>) {
-    test::same_tag<op::get_ordinal<Struct, Ident>, Ordinal>;
-    test::same_tag<op::get_field_id<Struct, Ident>, Id>;
-    test::same_tag<op::get_type_tag<Struct, Ident>, TypeTag>;
-    test::same_tag<op::get_ident<Struct, Ident>, Ident>;
-    test::same_tag<op::get_field_tag<Struct, Ident>, FieldTag>;
+    static_assert(std::is_same_v<op::get_ordinal<Struct, Ident>, Ordinal>);
+    static_assert(std::is_same_v<op::get_field_id<Struct, Ident>, Id>);
+    static_assert(std::is_same_v<op::get_type_tag<Struct, Ident>, TypeTag>);
+    static_assert(std::is_same_v<op::get_ident<Struct, Ident>, Ident>);
+    static_assert(std::is_same_v<op::get_field_tag<Struct, Ident>, FieldTag>);
     EXPECT_EQ((op::get_name_v<Struct, Ident>), identName);
   }
 
   if constexpr (!std::is_void_v<FieldTag>) {
-    test::same_tag<op::get_ordinal<Struct, FieldTag>, Ordinal>;
-    test::same_tag<op::get_field_id<Struct, FieldTag>, Id>;
-    test::same_tag<op::get_type_tag<Struct, FieldTag>, TypeTag>;
-    test::same_tag<op::get_ident<Struct, FieldTag>, Ident>;
-    test::same_tag<op::get_field_tag<Struct, FieldTag>, FieldTag>;
+    static_assert(std::is_same_v<op::get_ordinal<Struct, FieldTag>, Ordinal>);
+    static_assert(std::is_same_v<op::get_field_id<Struct, FieldTag>, Id>);
+    static_assert(std::is_same_v<op::get_type_tag<Struct, FieldTag>, TypeTag>);
+    static_assert(std::is_same_v<op::get_ident<Struct, FieldTag>, Ident>);
+    static_assert(
+        std::is_same_v<op::get_field_tag<Struct, FieldTag>, FieldTag>);
     EXPECT_EQ((op::get_name_v<Struct, FieldTag>), identName);
   }
 }
@@ -273,29 +282,40 @@ TEST(FieldsTest, IsReflectionMetadata) {
 TEST(FieldsTest, NotFoundFieldInfo) {
   using Struct = test_cpp2::cpp_reflection::struct3;
 
-  test::same_tag<op::get_ordinal<Struct, field_ordinal<0>>, field_ordinal<0>>;
-  test::same_tag<op::get_field_id<Struct, field_ordinal<0>>, field_id<0>>;
-  test::same_tag<op::get_type_tag<Struct, field_ordinal<0>>, void>;
-  test::same_tag<op::get_ident<Struct, field_ordinal<0>>, void>;
-  test::same_tag<op::get_field_tag<Struct, field_ordinal<0>>, void>;
-
-  test::same_tag<op::get_ordinal<Struct, field_id<200>>, field_ordinal<0>>;
-  test::same_tag<op::get_field_id<Struct, field_id<200>>, field_id<0>>;
-  test::same_tag<op::get_type_tag<Struct, field_id<200>>, void>;
-  test::same_tag<op::get_ident<Struct, field_id<200>>, void>;
-  test::same_tag<op::get_field_tag<Struct, field_id<200>>, void>;
-
-  test::same_tag<op::get_ordinal<Struct, binary_t>, field_ordinal<0>>;
-  test::same_tag<op::get_field_id<Struct, binary_t>, field_id<0>>;
-  test::same_tag<op::get_type_tag<Struct, binary_t>, void>;
-  test::same_tag<op::get_ident<Struct, binary_t>, void>;
-  test::same_tag<op::get_field_tag<Struct, binary_t>, void>;
-
-  test::same_tag<op::get_ordinal<Struct, ident::a>, field_ordinal<0>>;
-  test::same_tag<op::get_field_id<Struct, ident::a>, field_id<0>>;
-  test::same_tag<op::get_type_tag<Struct, ident::a>, void>;
-  test::same_tag<op::get_ident<Struct, ident::a>, void>;
-  test::same_tag<op::get_field_tag<Struct, ident::a>, void>;
+  static_assert(std::is_same_v<
+                op::get_ordinal<Struct, field_ordinal<0>>,
+                field_ordinal<0>>);
+  static_assert(
+      std::is_same_v<op::get_field_id<Struct, field_ordinal<0>>, field_id<0>>);
+  static_assert(
+      std::is_same_v<op::get_type_tag<Struct, field_ordinal<0>>, void>);
+  static_assert(std::is_same_v<op::get_ident<Struct, field_ordinal<0>>, void>);
+  static_assert(
+      std::is_same_v<op::get_field_tag<Struct, field_ordinal<0>>, void>);
+
+  static_assert(
+      std::is_same_v<op::get_ordinal<Struct, field_id<200>>, field_ordinal<0>>);
+  static_assert(
+      std::is_same_v<op::get_field_id<Struct, field_id<200>>, field_id<0>>);
+  static_assert(std::is_same_v<op::get_type_tag<Struct, field_id<200>>, void>);
+  static_assert(std::is_same_v<op::get_ident<Struct, field_id<200>>, void>);
+  static_assert(std::is_same_v<op::get_field_tag<Struct, field_id<200>>, void>);
+
+  static_assert(
+      std::is_same_v<op::get_ordinal<Struct, binary_t>, field_ordinal<0>>);
+  static_assert(
+      std::is_same_v<op::get_field_id<Struct, binary_t>, field_id<0>>);
+  static_assert(std::is_same_v<op::get_type_tag<Struct, binary_t>, void>);
+  static_assert(std::is_same_v<op::get_ident<Struct, binary_t>, void>);
+  static_assert(std::is_same_v<op::get_field_tag<Struct, binary_t>, void>);
+
+  static_assert(
+      std::is_same_v<op::get_ordinal<Struct, ident::a>, field_ordinal<0>>);
+  static_assert(
+      std::is_same_v<op::get_field_id<Struct, ident::a>, field_id<0>>);
+  static_assert(std::is_same_v<op::get_type_tag<Struct, ident::a>, void>);
+  static_assert(std::is_same_v<op::get_ident<Struct, ident::a>, void>);
+  static_assert(std::is_same_v<op::get_field_tag<Struct, ident::a>, void>);
 }
 
 template <typename Ident>
@@ -306,11 +326,14 @@ bool isIdentTag(folly::tag_t<Ident>) {
 TEST(FieldsTest, HelperAPIs) {
   using Struct = test_cpp2::cpp_reflection::struct3;
 
-  test::same_tag<op::get_native_type<Struct, field_ordinal<1>>, std::int32_t>;
-  test::same_tag<op::get_native_type<Struct, ident::fieldA>, std::int32_t>;
-  test::same_tag<
-      op::get_native_type<Struct, field_id<11>>,
-      std::deque<std::string>>;
+  static_assert(std::is_same_v<
+                op::get_native_type<Struct, field_ordinal<1>>,
+                std::int32_t>);
+  static_assert(
+      std::is_same_v<op::get_native_type<Struct, ident::fieldA>, std::int32_t>);
+  static_assert(std::is_same_v<
+                op::get_native_type<Struct, field_id<11>>,
+                std::deque<std::string>>);
   EXPECT_EQ((op::get_field_id_v<Struct, field_ordinal<1>>), FieldId{2});
   EXPECT_EQ((op::get_ordinal_v<Struct, field_id<2>>), FieldOrdinal{1});