CaseyCarter updated this revision to Diff 78379.
CaseyCarter marked an inline comment as done.
CaseyCarter added a comment.
Don't `STATIC_ASSERT`; `static_assert`.
https://reviews.llvm.org/D26782
Files:
test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
test/std/utilities/any/any.class/any.cons/value.pass.cpp
test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
test/std/utilities/utility/utility.inplace/inplace.pass.cpp
Index: test/std/utilities/utility/utility.inplace/inplace.pass.cpp
===================================================================
--- test/std/utilities/utility/utility.inplace/inplace.pass.cpp
+++ test/std/utilities/utility/utility.inplace/inplace.pass.cpp
@@ -11,21 +11,24 @@
// <utility>
-// struct in_place_tag { in_place_tag() = delete; };
-//
-// using in_place_t = in_place_tag(&)(unspecified);
+// struct in_place_t {
+// explicit in_place_t() = default;
+// };
+// inline constexpr in_place_t in_place{};
+
// template <class T>
-// using in_place_type_t = in_place_tag(&)(unspecified<T>);
-// template <size_t N>
-// using in_place_index_t = in_place_tag(&)(unspecified<N>);
-//
-// in_place_tag in_place(unspecified);
-//
-// template <class T>;
-// in_place_tag in_place(unspecified<T>);
-//
-// template <size_t N>
-// in_place_tag in_place(unspecified<N>);
+// struct in_place_type_t {
+// explicit in_place_type_t() = default;
+// };
+// template <class T>
+// inline constexpr in_place_type_t<T> in_place_type{};
+
+// template <size_t I>
+// struct in_place_index_t {
+// explicit in_place_index_t() = default;
+// };
+// template <size_t I>
+// inline constexpr in_place_index_t<I> in_place_index{};
#include <utility>
#include <cassert>
@@ -34,66 +37,38 @@
#include "test_macros.h"
#include "type_id.h"
-template <class Tp>
-struct CheckRet : std::false_type {};
-template <class Arg>
-struct CheckRet<std::in_place_tag(Arg)> : std::true_type {};
-
-TypeID const* test_fn(std::in_place_t) { return &makeTypeID<std::in_place_t>(); }
-template <class T>
-TypeID const* test_fn(std::in_place_type_t<T>)
-{ return &makeTypeID<std::in_place_type_t<T>>(); }
-
-template <size_t I>
-TypeID const* test_fn(std::in_place_index_t<I>)
-{ return &makeTypeID<std::in_place_index_t<I>>(); }
-
-// Concrete test overloads that don't have to be deduced.
-template <class Tag>
-TypeID const* concrete_test_fn(Tag) { return &makeTypeID<Tag>(); }
-
-template <class Tp>
-bool check_tag_basic() {
- using RawTp = typename std::remove_reference<Tp>::type;
- static_assert(std::is_lvalue_reference<Tp>::value, "");
- static_assert(std::is_function<RawTp>::value, "");
- static_assert(CheckRet<RawTp>::value, "");
- auto concrete_fn = concrete_test_fn<Tp>;
- return test_fn((Tp)std::in_place) == &makeTypeID<Tp>()
- && concrete_fn(std::in_place) == &makeTypeID<Tp>();
+template <class Tp, class Up>
+constexpr bool check_tag(Up) {
+ return std::is_same<Tp, std::decay_t<Tp>>::value
+ && std::is_same<Tp, Up>::value;
}
int main() {
- // test in_place_tag
- {
- static_assert(!std::is_default_constructible<std::in_place_tag>::value, "");
- }
// test in_place_t
{
using T = std::in_place_t;
- assert(check_tag_basic<std::in_place_t>());
- assert(test_fn((T)std::in_place) == &makeTypeID<T>());
+ static_assert(check_tag<T>(std::in_place));
}
// test in_place_type_t
{
using T1 = std::in_place_type_t<void>;
using T2 = std::in_place_type_t<int>;
using T3 = std::in_place_type_t<const int>;
- assert(check_tag_basic<T1>());
- assert(check_tag_basic<T2>());
- assert(check_tag_basic<T3>());
- static_assert(!std::is_same<T1, T2>::value && !std::is_same<T1, T3>::value, "");
- static_assert(!std::is_same<T2, T3>::value, "");
+ static_assert(!std::is_same<T1, T2>::value && !std::is_same<T1, T3>::value);
+ static_assert(!std::is_same<T2, T3>::value);
+ static_assert(check_tag<T1>(std::in_place_type<void>));
+ static_assert(check_tag<T2>(std::in_place_type<int>));
+ static_assert(check_tag<T3>(std::in_place_type<const int>));
}
// test in_place_index_t
{
using T1 = std::in_place_index_t<0>;
using T2 = std::in_place_index_t<1>;
using T3 = std::in_place_index_t<static_cast<size_t>(-1)>;
- assert(check_tag_basic<T1>());
- assert(check_tag_basic<T2>());
- assert(check_tag_basic<T3>());
- static_assert(!std::is_same<T1, T2>::value && !std::is_same<T1, T3>::value, "");
- static_assert(!std::is_same<T2, T3>::value, "");
+ static_assert(!std::is_same<T1, T2>::value && !std::is_same<T1, T3>::value);
+ static_assert(!std::is_same<T2, T3>::value);
+ static_assert(check_tag<T1>(std::in_place_index<0>));
+ static_assert(check_tag<T2>(std::in_place_index<1>));
+ static_assert(check_tag<T3>(std::in_place_index<static_cast<size_t>(-1)>));
}
-}
\ No newline at end of file
+}
Index: test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
===================================================================
--- test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
+++ test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
@@ -192,7 +192,6 @@
Type::reset();
{
any a((Type(42)));
- any const& ca = a;
assert(Type::count == 1);
assert(Type::copied == 0);
assert(Type::moved == 1);
Index: test/std/utilities/any/any.class/any.cons/value.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.cons/value.pass.cpp
+++ test/std/utilities/any/any.class/any.cons/value.pass.cpp
@@ -106,13 +106,12 @@
}
}
-// Test that any(ValueType&&) is *never* selected for a std::in_place type.
+// Test that any(ValueType&&) is *never* selected for a std::in_place_type_t specialization.
void test_sfinae_constraints() {
using BadTag = std::in_place_type_t<int>;
using OKTag = std::in_place_t;
- using OKDecay = std::decay_t<OKTag>;
// Test that the tag type is properly handled in SFINAE
- BadTag t = std::in_place;
+ BadTag t = std::in_place_type<int>;
OKTag ot = std::in_place;
{
std::any a(t);
@@ -124,12 +123,7 @@
}
{
std::any a(ot);
- assertContains<OKDecay>(a, ot);
- }
- {
- OKDecay d = ot;
- std::any a(d);
- assertContains<OKDecay>(a, ot);
+ assert(containsType<OKTag>(a));
}
{
struct Dummy { Dummy() = delete; };
Index: test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
===================================================================
--- test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
+++ test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp
@@ -40,7 +40,7 @@
assert(Type::count == 0);
Type::reset();
{
- any a(std::in_place<Type>);
+ any a(std::in_place_type<Type>);
assert(Type::count == 1);
assert(Type::copied == 0);
@@ -50,7 +50,7 @@
assert(Type::count == 0);
Type::reset();
{ // Test that the in_place argument is properly decayed
- any a(std::in_place<Type&>);
+ any a(std::in_place_type<Type&>);
assert(Type::count == 1);
assert(Type::copied == 0);
@@ -60,7 +60,7 @@
assert(Type::count == 0);
Type::reset();
{
- any a(std::in_place<Type>, 101);
+ any a(std::in_place_type<Type>, 101);
assert(Type::count == 1);
assert(Type::copied == 0);
@@ -70,7 +70,7 @@
assert(Type::count == 0);
Type::reset();
{
- any a(std::in_place<Type>, -1, 42, -1);
+ any a(std::in_place_type<Type>, -1, 42, -1);
assert(Type::count == 1);
assert(Type::copied == 0);
@@ -86,21 +86,21 @@
// constructing from a small type should perform no allocations.
DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
{
- any a(std::in_place<Type>);
+ any a(std::in_place_type<Type>);
assertArgsMatch<Type>(a);
}
{
- any a(std::in_place<Type>, -1, 42, -1);
+ any a(std::in_place_type<Type>, -1, 42, -1);
assertArgsMatch<Type, int, int, int>(a);
}
// initializer_list constructor tests
{
- any a(std::in_place<Type>, {-1, 42, -1});
+ any a(std::in_place_type<Type>, {-1, 42, -1});
assertArgsMatch<Type, std::initializer_list<int>>(a);
}
{
int x = 42;
- any a(std::in_place<Type&>, {-1, 42, -1}, x);
+ any a(std::in_place_type<Type&>, {-1, 42, -1}, x);
assertArgsMatch<Type, std::initializer_list<int>, int&>(a);
}
}
@@ -111,7 +111,7 @@
{
using Type = decltype(test_func);
using DecayT = void(*)();
- any a(std::in_place<Type>, test_func);
+ any a(std::in_place_type<Type>, test_func);
assert(containsType<DecayT>(a));
assert(any_cast<DecayT>(a) == test_func);
}
@@ -119,14 +119,14 @@
int my_arr[5];
using Type = int(&)[5];
using DecayT = int*;
- any a(std::in_place<Type>, my_arr);
+ any a(std::in_place_type<Type>, my_arr);
assert(containsType<DecayT>(a));
assert(any_cast<DecayT>(a) == my_arr);
}
{
using Type = int[5];
using DecayT = int*;
- any a(std::in_place<Type>);
+ any a(std::in_place_type<Type>);
assert(containsType<DecayT>(a));
assert(any_cast<DecayT>(a) == nullptr);
}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
