Skip to content

Commit

Permalink
Replace same_tag with std::is_same_v
Browse files Browse the repository at this point in the history 
Summary: Replace `test::same_tag<>` with `std::is_same_v<>`

Reviewed By: Mizuchi

Differential Revision: D68788509

fbshipit-source-id: 349ce7237ac8faa7d9e0bfc350face95ab263831
  • Loading branch information
@yoney @facebook-github-bot
yoney authored and facebook-github-bot committed Jan 28, 2025
1 parent cc82b5c commit ad57e3b
Show file tree
Hide file tree
Showing 4 changed files with 167 additions and 145 deletions.
42 changes: 21 additions & 21 deletions third-party/thrift/src/thrift/lib/cpp2/type/NativeTypeTest.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,32 +41,32 @@ 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) {
static_assert(std::is_same_v<int8_t, native_type<byte_t>>);
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>);
Expand All @@ -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) {
Expand All @@ -99,24 +99,24 @@ 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>>>);
}

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>>>);
}
Expand Down
103 changes: 56 additions & 47 deletions third-party/thrift/src/thrift/lib/cpp2/type/TagTest.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@

#include <list>
#include <map>
#include <type_traits>
#include <unordered_set>

#include <folly/portability/GTest.h>
Expand Down Expand Up @@ -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>{}))>);

Expand Down
10 changes: 0 additions & 10 deletions third-party/thrift/src/thrift/lib/cpp2/type/Testing.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down
Loading

0 comments on commit ad57e3b

Please sign in to comment.