Skip to content

Commit 2c774a0

Browse files
yoneyfacebook-github-bot
yoney
authored and
facebook-github-bot
committed
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
1 parent 6df716a commit 2c774a0

File tree

4 files changed

+167
-145
lines changed

4 files changed

+167
-145
lines changed

‎thrift/lib/cpp2/type/NativeTypeTest.cpp

+21-21
Original file line numberDiff line numberDiff line change
@@ -41,32 +41,32 @@ TEST(NativeTypeTest, UndefinedOverloading) {
4141

4242
TEST(NativeTypeTest, Void) {
4343
static_assert(std::is_same_v<void, native_type<void_t>>);
44-
static_assert(test::same_tag<void_t, infer_tag<void>>);
45-
static_assert(test::same_tag<void_t, infer_tag<std::nullptr_t>>);
44+
static_assert(std::is_same_v<void_t, infer_tag<void>>);
45+
static_assert(std::is_same_v<void_t, infer_tag<std::nullptr_t>>);
4646
}
4747

4848
TEST(NativeTypeTest, Bool) {
4949
static_assert(std::is_same_v<bool, native_type<bool_t>>);
50-
static_assert(test::same_tag<bool_t, infer_tag<bool>>);
50+
static_assert(std::is_same_v<bool_t, infer_tag<bool>>);
5151
}
5252

5353
TEST(InferTagTest, Tag) {
54-
static_assert(test::same_tag<byte_t, infer_tag<byte_t>>);
54+
static_assert(std::is_same_v<byte_t, infer_tag<byte_t>>);
5555
}
5656

5757
TEST(InferTagTest, Integer) {
5858
static_assert(std::is_same_v<int8_t, native_type<byte_t>>);
5959
static_assert(std::is_same_v<int16_t, native_type<i16_t>>);
6060
static_assert(std::is_same_v<int32_t, native_type<i32_t>>);
6161
static_assert(std::is_same_v<int64_t, native_type<i64_t>>);
62-
static_assert(test::same_tag<byte_t, infer_tag<int8_t>>);
63-
static_assert(test::same_tag<i16_t, infer_tag<int16_t>>);
64-
static_assert(test::same_tag<i32_t, infer_tag<int32_t>>);
65-
static_assert(test::same_tag<i64_t, infer_tag<int64_t>>);
66-
static_assert(test::same_tag<cpp_type<uint8_t, byte_t>, infer_tag<uint8_t>>);
67-
static_assert(test::same_tag<cpp_type<uint16_t, i16_t>, infer_tag<uint16_t>>);
68-
static_assert(test::same_tag<cpp_type<uint32_t, i32_t>, infer_tag<uint32_t>>);
69-
static_assert(test::same_tag<cpp_type<uint64_t, i64_t>, infer_tag<uint64_t>>);
62+
static_assert(std::is_same_v<byte_t, infer_tag<int8_t>>);
63+
static_assert(std::is_same_v<i16_t, infer_tag<int16_t>>);
64+
static_assert(std::is_same_v<i32_t, infer_tag<int32_t>>);
65+
static_assert(std::is_same_v<i64_t, infer_tag<int64_t>>);
66+
static_assert(std::is_same_v<cpp_type<uint8_t, byte_t>, infer_tag<uint8_t>>);
67+
static_assert(std::is_same_v<cpp_type<uint16_t, i16_t>, infer_tag<uint16_t>>);
68+
static_assert(std::is_same_v<cpp_type<uint32_t, i32_t>, infer_tag<uint32_t>>);
69+
static_assert(std::is_same_v<cpp_type<uint64_t, i64_t>, infer_tag<uint64_t>>);
7070

7171
static_assert(type::is_a_v<infer_tag<char>, byte_t>);
7272
static_assert(type::is_a_v<infer_tag<signed char>, byte_t>);
@@ -86,8 +86,8 @@ TEST(InferTagTest, Integer) {
8686
TEST(InferTagTest, Floating) {
8787
static_assert(std::is_same_v<float, native_type<float_t>>);
8888
static_assert(std::is_same_v<double, native_type<double_t>>);
89-
static_assert(test::same_tag<float_t, infer_tag<float>>);
90-
static_assert(test::same_tag<double_t, infer_tag<double>>);
89+
static_assert(std::is_same_v<float_t, infer_tag<float>>);
90+
static_assert(std::is_same_v<double_t, infer_tag<double>>);
9191
}
9292

9393
TEST(InferTagTest, Strings) {
@@ -99,24 +99,24 @@ TEST(InferTagTest, Strings) {
9999

100100
TEST(InferTagTest, Containers) {
101101
static_assert(
102-
test::same_tag<native_type<list<i32_t>>, std::vector<std::int32_t>>);
102+
std::is_same_v<native_type<list<i32_t>>, std::vector<std::int32_t>>);
103103
static_assert(
104-
test::same_tag<list<i32_t>, infer_tag<std::vector<std::int32_t>>>);
104+
std::is_same_v<list<i32_t>, infer_tag<std::vector<std::int32_t>>>);
105105
static_assert(
106-
test::same_tag<native_type<set<i32_t>>, std::set<std::int32_t>>);
107-
static_assert(test::same_tag<set<i32_t>, infer_tag<std::set<std::int32_t>>>);
108-
static_assert(test::same_tag<
106+
std::is_same_v<native_type<set<i32_t>>, std::set<std::int32_t>>);
107+
static_assert(std::is_same_v<set<i32_t>, infer_tag<std::set<std::int32_t>>>);
108+
static_assert(std::is_same_v<
109109
native_type<map<i32_t, bool_t>>,
110110
std::map<std::int32_t, bool>>);
111-
static_assert(test::same_tag<
111+
static_assert(std::is_same_v<
112112
map<i32_t, bool_t>,
113113
infer_tag<std::map<std::int32_t, bool>>>);
114114
}
115115

116116
TEST(InferTagTest, Wrap) {
117117
struct FooStruct {};
118118
struct Foo : detail::Wrap<FooStruct, struct_t<FooStruct>> {};
119-
static_assert(test::same_tag<
119+
static_assert(std::is_same_v<
120120
infer_tag<Foo>,
121121
adapted<InlineAdapter<Foo>, struct_t<FooStruct>>>);
122122
}

‎thrift/lib/cpp2/type/TagTest.cpp

+56-47
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818

1919
#include <list>
2020
#include <map>
21+
#include <type_traits>
2122
#include <unordered_set>
2223

2324
#include <folly/portability/GTest.h>
@@ -77,96 +78,104 @@ cpp_type<set<Specialized>, std::unordered_set<int>> testOverload(
7778
map<Specialized, Specialized> testOverload(map<Specialized, Specialized>);
7879

7980
namespace {
80-
using test::same_tag;
8181
using test::TestAdapter;
8282

8383
// Test that type tags can be used to find an overload in ~constant time
8484
// by the compiler.
85-
static_assert(same_tag<all_c, decltype(testOverload(primitive_c{}))>);
86-
static_assert(same_tag<void_t, decltype(testOverload(void_t{}))>);
87-
static_assert(same_tag<integral_c, decltype(testOverload(bool_t{}))>);
88-
static_assert(same_tag<byte_t, decltype(testOverload(byte_t{}))>);
89-
static_assert(same_tag<integral_c, decltype(testOverload(i16_t{}))>);
90-
static_assert(same_tag<i32_t, decltype(testOverload(i32_t{}))>);
91-
static_assert(same_tag<i64_t, decltype(testOverload(i64_t{}))>);
92-
static_assert(same_tag<floating_point_c, decltype(testOverload(float_t{}))>);
93-
static_assert(same_tag<double_t, decltype(testOverload(double_t{}))>);
94-
static_assert(same_tag<string_t, decltype(testOverload(string_t{}))>);
95-
static_assert(same_tag<string_c, decltype(testOverload(binary_t{}))>);
96-
97-
static_assert(same_tag<enum_c, decltype(testOverload(enum_c{}))>);
98-
static_assert(same_tag<enum_c, decltype(testOverload(enum_t<General>{}))>);
99-
static_assert(same_tag<
85+
static_assert(std::is_same_v<all_c, decltype(testOverload(primitive_c{}))>);
86+
static_assert(std::is_same_v<void_t, decltype(testOverload(void_t{}))>);
87+
static_assert(std::is_same_v<integral_c, decltype(testOverload(bool_t{}))>);
88+
static_assert(std::is_same_v<byte_t, decltype(testOverload(byte_t{}))>);
89+
static_assert(std::is_same_v<integral_c, decltype(testOverload(i16_t{}))>);
90+
static_assert(std::is_same_v<i32_t, decltype(testOverload(i32_t{}))>);
91+
static_assert(std::is_same_v<i64_t, decltype(testOverload(i64_t{}))>);
92+
static_assert(
93+
std::is_same_v<floating_point_c, decltype(testOverload(float_t{}))>);
94+
static_assert(std::is_same_v<double_t, decltype(testOverload(double_t{}))>);
95+
static_assert(std::is_same_v<string_t, decltype(testOverload(string_t{}))>);
96+
static_assert(std::is_same_v<string_c, decltype(testOverload(binary_t{}))>);
97+
98+
static_assert(std::is_same_v<enum_c, decltype(testOverload(enum_c{}))>);
99+
static_assert(
100+
std::is_same_v<enum_c, decltype(testOverload(enum_t<General>{}))>);
101+
static_assert(std::is_same_v<
100102
enum_t<Specialized>,
101103
decltype(testOverload(enum_t<Specialized>{}))>);
102104

103-
static_assert(same_tag<struct_c, decltype(testOverload(struct_c{}))>);
104-
static_assert(same_tag<struct_c, decltype(testOverload(struct_t<General>{}))>);
105-
static_assert(same_tag<
105+
static_assert(std::is_same_v<struct_c, decltype(testOverload(struct_c{}))>);
106+
static_assert(
107+
std::is_same_v<struct_c, decltype(testOverload(struct_t<General>{}))>);
108+
static_assert(std::is_same_v<
106109
struct_t<Specialized>,
107110
decltype(testOverload(struct_t<Specialized>{}))>);
108111

109-
static_assert(same_tag<structured_c, decltype(testOverload(union_c{}))>);
112+
static_assert(std::is_same_v<structured_c, decltype(testOverload(union_c{}))>);
110113
static_assert(
111-
same_tag<structured_c, decltype(testOverload(union_t<General>{}))>);
112-
static_assert(same_tag<
114+
std::is_same_v<structured_c, decltype(testOverload(union_t<General>{}))>);
115+
static_assert(std::is_same_v<
113116
union_t<Specialized>,
114117
decltype(testOverload(union_t<Specialized>{}))>);
115118

116-
static_assert(same_tag<struct_except_c, decltype(testOverload(exception_c{}))>);
117119
static_assert(
118-
same_tag<struct_except_c, decltype(testOverload(exception_t<General>{}))>);
119-
static_assert(same_tag<
120+
std::is_same_v<struct_except_c, decltype(testOverload(exception_c{}))>);
121+
static_assert(std::is_same_v<
122+
struct_except_c,
123+
decltype(testOverload(exception_t<General>{}))>);
124+
static_assert(std::is_same_v<
120125
exception_t<Specialized>,
121126
decltype(testOverload(exception_t<Specialized>{}))>);
122127

123-
static_assert(same_tag<list_c, decltype(testOverload(list_c{}))>);
124-
static_assert(same_tag<list_c, decltype(testOverload(list<void_t>{}))>);
125-
static_assert(same_tag<
128+
static_assert(std::is_same_v<list_c, decltype(testOverload(list_c{}))>);
129+
static_assert(std::is_same_v<list_c, decltype(testOverload(list<void_t>{}))>);
130+
static_assert(std::is_same_v<
126131
cpp_type<list<Specialized>, std::list<Specialized>>,
127132
decltype(testOverload(
128133
cpp_type<list<Specialized>, std::list<Specialized>>{}))>);
129-
static_assert(same_tag<
134+
static_assert(std::is_same_v<
130135
cpp_type<list<Specialized>, std::list<Specialized>>,
131136
decltype(testOverload(
132137
cpp_type<list<Specialized>, std::list<Specialized>>{}))>);
133138

134-
static_assert(same_tag<container_c, decltype(testOverload(set_c{}))>);
135-
static_assert(same_tag<container_c, decltype(testOverload(set<void_t>{}))>);
139+
static_assert(std::is_same_v<container_c, decltype(testOverload(set_c{}))>);
136140
static_assert(
137-
same_tag<container_c, decltype(testOverload(set<Specialized>{}))>);
138-
static_assert(same_tag<
141+
std::is_same_v<container_c, decltype(testOverload(set<void_t>{}))>);
142+
static_assert(
143+
std::is_same_v<container_c, decltype(testOverload(set<Specialized>{}))>);
144+
static_assert(std::is_same_v<
139145
cpp_type<set<Specialized>, std::unordered_set<int>>,
140146
decltype(testOverload(
141147
cpp_type<set<Specialized>, std::unordered_set<int>>{}))>);
142148

143-
static_assert(same_tag<map_c, decltype(testOverload(map_c{}))>);
144-
static_assert(same_tag<map_c, decltype(testOverload(map<void_t, void_t>{}))>);
149+
static_assert(std::is_same_v<map_c, decltype(testOverload(map_c{}))>);
150+
static_assert(
151+
std::is_same_v<map_c, decltype(testOverload(map<void_t, void_t>{}))>);
145152
static_assert(
146-
same_tag<map_c, decltype(testOverload(map<Specialized, void_t>{}))>);
153+
std::is_same_v<map_c, decltype(testOverload(map<Specialized, void_t>{}))>);
147154
static_assert(
148-
same_tag<map_c, decltype(testOverload(map<void_t, Specialized>{}))>);
149-
static_assert(same_tag<
155+
std::is_same_v<map_c, decltype(testOverload(map<void_t, Specialized>{}))>);
156+
static_assert(std::is_same_v<
150157
map<Specialized, Specialized>,
151158
decltype(testOverload(map<Specialized, Specialized>{}))>);
152159

153160
// Adapted types are convertable to the underlying tag.
154-
static_assert(
155-
same_tag<void_t, decltype(testOverload(adapted<TestAdapter, void_t>{}))>);
156-
static_assert(same_tag<
161+
static_assert(std::is_same_v<
162+
void_t,
163+
decltype(testOverload(adapted<TestAdapter, void_t>{}))>);
164+
static_assert(std::is_same_v<
157165
list_c,
158166
decltype(testOverload(adapted<TestAdapter, list<enum_c>>{}))>);
159167
// CppType types are convertable to the underlying tag.
160-
static_assert(
161-
same_tag<void_t, decltype(testOverload(cpp_type<TestAdapter, void_t>{}))>);
162-
static_assert(same_tag<
168+
static_assert(std::is_same_v<
169+
void_t,
170+
decltype(testOverload(cpp_type<TestAdapter, void_t>{}))>);
171+
static_assert(std::is_same_v<
163172
list_c,
164173
decltype(testOverload(cpp_type<TestAdapter, list<enum_c>>{}))>);
165174

166-
static_assert(same_tag<service_c, decltype(testOverload(service_c{}))>);
175+
static_assert(std::is_same_v<service_c, decltype(testOverload(service_c{}))>);
167176
static_assert(
168-
same_tag<service_c, decltype(testOverload(service_t<General>{}))>);
169-
static_assert(same_tag<
177+
std::is_same_v<service_c, decltype(testOverload(service_t<General>{}))>);
178+
static_assert(std::is_same_v<
170179
service_t<Specialized>,
171180
decltype(testOverload(service_t<Specialized>{}))>);
172181

‎thrift/lib/cpp2/type/Testing.h

-10
Original file line numberDiff line numberDiff line change
@@ -29,16 +29,6 @@
2929

3030
namespace apache::thrift::test {
3131

32-
// Helper to check if the tags matches.
33-
// For example:
34-
// static_assert(same_tag<bool_t, void_t>);
35-
// Will produce an error message similar to:
36-
// static assertion failed due to requirement
37-
// test::same_tag<apache::thrift::type::bool_t, apache::thrift::type::void_t>
38-
// static_assert(test::same_tag<bool_t, void_t>);
39-
template <typename Expected, typename Actual>
40-
constexpr bool same_tag = std::is_same_v<Expected, Actual>;
41-
4232
template <typename T>
4333
struct TestValue {
4434
T value;

0 commit comments

Comments
 (0)