[libcxx] [test] Test changes for P0504R0 "Revisiting in-place tag types for any/optional/variant"

[CaseyCarter]

Summary

Note that this does not implement the product code changes to <utility> and <any>, this is only the necessary changes to accompanying test code.

[CaseyCarter]

Remove unused reference variable in any_cast_reference.pass.cpp.

[mclow.lists]

Do these tests pass with the current <any> implementation, or will they have to wait?

test/std/utilities/utility/utility.inplace/inplace.pass.cpp

40

Please just use static_assert(x) instead. Since this is C++1z only, you don't need to supply a message. If the test fails, the compiler will give you file and line #.

If I see an all caps STATIC_ASSERT, then my first bit of research has to be "how is this different from static_assert?"

[CaseyCarter]

Do these tests pass with the current <any> implementation, or will they have to wait?

These tests do not pass without making the changes required in P0504R0 to <utility> and <any>. (Interestingly <optional> is unaffected; its use of in_place_t and in_place is source-compatible despite the changed definitions of those names.) I would have made those changes as well, but my request for permission to contribute changes to non-test code hasn't yet returned from the void into which I cast it. If neither of you get around to it, I may put an hour into it over the weekend.

test/std/utilities/utility/utility.inplace/inplace.pass.cpp

40

static_assert(false); in Visual C++ diagnoses with the incredibly informative:

inplace.pass.cpp(59): error C2607: static assertion failed

so I've developed this habit which inadvertently leaked into the diff. Fixing.

[CaseyCarter]

Don't STATIC_ASSERT; static_assert.

[EricWF]

LGTM. This patch misses any.modifiers/emplace.pass.cpp but I'll fix that up and commit with the libc++ changes!

[EricWF]

r287249. Thanks again!

test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp

     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);

     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);

     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);

     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);

     // 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);
     }
 }

     {
         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);
     }

         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);
     }

test/std/utilities/any/any.class/any.cons/value.pass.cpp

     }
 }
 
-// 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);

     }
     {
         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; };

test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

     Type::reset();
     {
         any a((Type(42)));
-        any const& ca = a;
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 1);

test/std/utilities/utility/utility.inplace/inplace.pass.cpp

 
 // <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>

 #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 {};
+#define STATIC_ASSERT(...) static_assert((__VA_ARGS__), #__VA_ARGS__)
 
-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)>));
     }
-}
+}