Patch for N3655 (Transformation type traits) with Howard's additions

llvm-svn: 185597

24 files changed, 302 insertions, 59 deletions

diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
index 2250d3f475c..28bbedee174 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.arr/remove_all_extents.pass.cpp
@@ -15,18 +15,27 @@
 
 enum Enum {zero, one_};
 
+template <class T, class U>
+void test_remove_all_extents()
+{
+    static_assert((std::is_same<typename std::remove_all_extents<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::remove_all_extents_t<T>,     U>::value), "");
+#endif
+}
+
 int main()
 {
-    static_assert((std::is_same<std::remove_all_extents<int>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<const Enum>::type, const Enum>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<int[]>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<const int[]>::type, const int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<int[3]>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<const int[3]>::type, const int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<int[][3]>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<const int[][3]>::type, const int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<int[2][3]>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<const int[2][3]>::type, const int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<int[1][2][3]>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_all_extents<const int[1][2][3]>::type, const int>::value), "");
+    test_remove_all_extents<int, int> ();
+    test_remove_all_extents<const Enum, const Enum> ();
+    test_remove_all_extents<int[], int> ();
+    test_remove_all_extents<const int[], const int> ();
+    test_remove_all_extents<int[3], int> ();
+    test_remove_all_extents<const int[3], const int> ();
+    test_remove_all_extents<int[][3], int> ();
+    test_remove_all_extents<const int[][3], const int> ();
+    test_remove_all_extents<int[2][3], int> ();
+    test_remove_all_extents<const int[2][3], const int> ();
+    test_remove_all_extents<int[1][2][3], int> ();
+    test_remove_all_extents<const int[1][2][3], const int> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
index dcf9bdc101a..c688c26b9a5 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.arr/remove_extent.pass.cpp
@@ -15,18 +15,28 @@
 
 enum Enum {zero, one_};
 
+template <class T, class U>
+void test_remove_extent()
+{
+    static_assert((std::is_same<typename std::remove_extent<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::remove_extent_t<T>,     U>::value), "");
+#endif
+}
+
+
 int main()
 {
-    static_assert((std::is_same<std::remove_extent<int>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_extent<const Enum>::type, const Enum>::value), "");
-    static_assert((std::is_same<std::remove_extent<int[]>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_extent<const int[]>::type, const int>::value), "");
-    static_assert((std::is_same<std::remove_extent<int[3]>::type, int>::value), "");
-    static_assert((std::is_same<std::remove_extent<const int[3]>::type, const int>::value), "");
-    static_assert((std::is_same<std::remove_extent<int[][3]>::type, int[3]>::value), "");
-    static_assert((std::is_same<std::remove_extent<const int[][3]>::type, const int[3]>::value), "");
-    static_assert((std::is_same<std::remove_extent<int[2][3]>::type, int[3]>::value), "");
-    static_assert((std::is_same<std::remove_extent<const int[2][3]>::type, const int[3]>::value), "");
-    static_assert((std::is_same<std::remove_extent<int[1][2][3]>::type, int[2][3]>::value), "");
-    static_assert((std::is_same<std::remove_extent<const int[1][2][3]>::type, const int[2][3]>::value), "");
+    test_remove_extent<int, int> ();
+    test_remove_extent<const Enum, const Enum> ();
+    test_remove_extent<int[], int> ();
+    test_remove_extent<const int[], const int> ();
+    test_remove_extent<int[3], int> ();
+    test_remove_extent<const int[3], const int> ();
+    test_remove_extent<int[][3], int[3]> ();
+    test_remove_extent<const int[][3], const int[3]> ();
+    test_remove_extent<int[2][3], int[3]> ();
+    test_remove_extent<const int[2][3], const int[3]> ();
+    test_remove_extent<int[1][2][3], int[2][3]> ();
+    test_remove_extent<const int[1][2][3], const int[2][3]> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
index 6fc952ad5cb..19b1fb4d01b 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_const.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_add_const_imp()
 {
     static_assert((std::is_same<typename std::add_const<T>::type, const U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::add_const_t<T>, U>::value), "");
+#endif
 }
 
 template <class T>
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
index 8a0f6e53f76..4905e518e12 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_cv.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_add_cv_imp()
 {
     static_assert((std::is_same<typename std::add_cv<T>::type, const volatile U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::add_cv_t<T>, U>::value), "");
+#endif
 }
 
 template <class T>
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
index 09d62b65626..7a12c44a2c6 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/add_volatile.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_add_volatile_imp()
 {
     static_assert((std::is_same<typename std::add_volatile<T>::type, volatile U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::add_volatile_t<T>, U>::value), "");
+#endif
 }
 
 template <class T>
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
index 9e433cd8af5..cd2faf786d8 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_const.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_remove_const_imp()
 {
     static_assert((std::is_same<typename std::remove_const<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::remove_const_t<T>, U>::value), "");
+#endif
 }
 
 template <class T>
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
index dd8a0d6ad62..3f6405c8280 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_cv.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_remove_cv_imp()
 {
     static_assert((std::is_same<typename std::remove_cv<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::remove_cv_t<T>, U>::value), "");
+#endif
 }
 
 template <class T>
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
index 173a0f52fc2..6258a9039b4 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.cv/remove_volatile.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_remove_volatile_imp()
 {
     static_assert((std::is_same<typename std::remove_volatile<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::remove_volatile_t<T>, U>::value), "");
+#endif
 }
 
 template <class T>
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
index 323fd5e4cfb..d1b77004f37 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp
@@ -17,106 +17,169 @@ int main()
 {
     {
     typedef std::aligned_storage<10, 1 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<10, 1>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 1, "");
     static_assert(sizeof(T1) == 10, "");
     }
     {
     typedef std::aligned_storage<10, 2 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<10, 2>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 2, "");
     static_assert(sizeof(T1) == 10, "");
     }
     {
     typedef std::aligned_storage<10, 4 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<10, 4>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 12, "");
     }
     {
     typedef std::aligned_storage<10, 8 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<10, 8>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
     {
     typedef std::aligned_storage<10, 16 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<10, 16>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 16, "");
     static_assert(sizeof(T1) == 16, "");
     }
     {
     typedef std::aligned_storage<10, 32 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<10, 32>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 32, "");
     static_assert(sizeof(T1) == 32, "");
     }
     {
     typedef std::aligned_storage<20, 32 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<20, 32>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 32, "");
     static_assert(sizeof(T1) == 32, "");
     }
     {
     typedef std::aligned_storage<40, 32 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<40, 32>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 32, "");
     static_assert(sizeof(T1) == 64, "");
     }
     {
     typedef std::aligned_storage<12, 16 >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<12, 16>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 16, "");
     static_assert(sizeof(T1) == 16, "");
     }
     {
     typedef std::aligned_storage<1>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<1>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 1, "");
     static_assert(sizeof(T1) == 1, "");
     }
     {
     typedef std::aligned_storage<2>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<2>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 2, "");
     static_assert(sizeof(T1) == 2, "");
     }
     {
     typedef std::aligned_storage<3>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<3>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 2, "");
     static_assert(sizeof(T1) == 4, "");
     }
     {
     typedef std::aligned_storage<4>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<4>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 4, "");
     }
     {
     typedef std::aligned_storage<5>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<5>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 8, "");
     }
     {
     typedef std::aligned_storage<7>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<7>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 8, "");
     }
     {
     typedef std::aligned_storage<8>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<8>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 8, "");
     }
     {
     typedef std::aligned_storage<9>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<9>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
     {
     typedef std::aligned_storage<15>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<15>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
     {
     typedef std::aligned_storage<16>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<16>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 16, "");
     static_assert(sizeof(T1) == 16, "");
     }
     {
     typedef std::aligned_storage<17>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<17>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 16, "");
     static_assert(sizeof(T1) == 32, "");
     }
     {
     typedef std::aligned_storage<10>::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_storage_t<10>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
index b07a06479d6..ae849ca5455 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
@@ -18,46 +18,73 @@ int main()
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     {
     typedef std::aligned_union<10, char >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<10, char>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 1, "");
     static_assert(sizeof(T1) == 10, "");
     }
     {
     typedef std::aligned_union<10, short >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<10, short>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 2, "");
     static_assert(sizeof(T1) == 10, "");
     }
     {
     typedef std::aligned_union<10, int >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<10, int>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 12, "");
     }
     {
     typedef std::aligned_union<10, double >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<10, double>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 8, "");
     static_assert(sizeof(T1) == 16, "");
     }
     {
     typedef std::aligned_union<10, short, char >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<10, short, char>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 2, "");
     static_assert(sizeof(T1) == 10, "");
     }
     {
     typedef std::aligned_union<10, char, short >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<10, char, short>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 2, "");
     static_assert(sizeof(T1) == 10, "");
     }
     {
     typedef std::aligned_union<2, int, char, short >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<2, int, char, short>, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 4, "");
     }
     {
     typedef std::aligned_union<2, char, int, short >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<2, char, int, short >, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 4, "");
     }
     {
     typedef std::aligned_union<2, char, short, int >::type T1;
+#if _LIBCPP_STD_VER > 11
+    static_assert(std::is_same<std::aligned_union_t<2, char, short, int >, T1>::value, "" );
+#endif
     static_assert(std::alignment_of<T1>::value == 4, "");
     static_assert(sizeof(T1) == 4, "");
     }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
index 600de3c9ec5..7f01e4ba0a7 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/common_type.pass.cpp
@@ -17,10 +17,22 @@ int main()
 {
     static_assert((std::is_same<std::common_type<int>::type, int>::value), "");
     static_assert((std::is_same<std::common_type<char>::type, char>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::common_type_t<int>, int>::value), "");
+    static_assert((std::is_same<std::common_type_t<char>, char>::value), "");
+#endif
 
     static_assert((std::is_same<std::common_type<double, char>::type, double>::value), "");
     static_assert((std::is_same<std::common_type<short, char>::type, int>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::common_type_t<double, char>, double>::value), "");
+    static_assert((std::is_same<std::common_type_t<short, char>, int>::value), "");
+#endif
 
     static_assert((std::is_same<std::common_type<double, char, long long>::type, double>::value), "");
     static_assert((std::is_same<std::common_type<unsigned, char, long long>::type, long long>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::common_type_t<double, char, long long>, double>::value), "");
+    static_assert((std::is_same<std::common_type_t<unsigned, char, long long>, long long>::value), "");
+#endif
 }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
index e4741a97e78..ac11e3a4ce8 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/conditional.pass.cpp
@@ -17,4 +17,8 @@ int main()
 {
     static_assert((std::is_same<std::conditional<true, char, int>::type, char>::value), "");
     static_assert((std::is_same<std::conditional<false, char, int>::type, int>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::conditional_t<true, char, int>, char>::value), "");
+    static_assert((std::is_same<std::conditional_t<false, char, int>, int>::value), "");
+#endif
 }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
index 5416f2ad6c1..bd8ae0e297b 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_decay()
 {
     static_assert((std::is_same<typename std::decay<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::decay_t<T>,     U>::value), "");
+#endif
 }
 
 int main()
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
index 8eae93aebf0..eb72b0f393b 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/enable_if.pass.cpp
@@ -17,4 +17,8 @@ int main()
 {
     static_assert((std::is_same<std::enable_if<true>::type, void>::value), "");
     static_assert((std::is_same<std::enable_if<true, int>::type, int>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::enable_if_t<true>, void>::value), "");
+    static_assert((std::is_same<std::enable_if_t<true, int>, int>::value), "");
+#endif
 }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
new file mode 100644
index 00000000000..8ce894578c4
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// type_traits
+
+// enable_if
+
+#include <type_traits>
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    typedef std::enable_if_t<false> A;
+#else
+    static_assert ( false, "" );
+#endif
+}
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
index 33c0ed4af22..368a3eb5dc6 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
@@ -34,8 +34,36 @@ struct wat
     void foo();
 };
 
+template <class T, class U>
+void test_result_of_imp()
+{
+    static_assert((std::is_same<typename std::result_of<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::result_of_t<T>, U>::value), "");
+#endif
+}
+
 int main()
 {
+    test_result_of_imp<S(int), short> ();
+    test_result_of_imp<S&(unsigned char, int&), double> ();
+    test_result_of_imp<PF1(), bool> ();
+    test_result_of_imp<PMS(std::unique_ptr<S>, int), void> ();
+    test_result_of_imp<PMS(S, int), void> ();
+    test_result_of_imp<PMS(const S&, int), void> ();
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    test_result_of_imp<PMD(S), char&&> ();
+#endif
+    test_result_of_imp<PMD(const S*), const char&> ();
+#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+    using type1 = std::result_of<decltype(&wat::foo)(wat)>::type;
+#endif
+#if _LIBCPP_STD_VER > 11
+    using type2 = std::result_of_t<decltype(&wat::foo)(wat)>;
+#endif
+
+
+
     static_assert((std::is_same<std::result_of<S(int)>::type, short>::value), "Error!");
     static_assert((std::is_same<std::result_of<S&(unsigned char, int&)>::type, double>::value), "Error!");
     static_assert((std::is_same<std::result_of<PF1()>::type, bool>::value), "Error!");
@@ -46,5 +74,7 @@ int main()
     static_assert((std::is_same<std::result_of<PMD(S)>::type, char&&>::value), "Error!");
 #endif
     static_assert((std::is_same<std::result_of<PMD(const S*)>::type, const char&>::value), "Error!");
+#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
     using type = std::result_of<decltype(&wat::foo)(wat)>::type;
+#endif
 }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
index a21120bdfde..728062b7068 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
@@ -14,20 +14,28 @@
 #include <type_traits>
 #include <climits>
 
+enum E { V = INT_MIN };
+enum F { W = UINT_MAX };
+
 int main()
 {
-    enum E { V = INT_MIN };
-    enum F { W = UINT_MAX };
-
     static_assert((std::is_same<std::underlying_type<E>::type, int>::value),
                   "E has the wrong underlying type");
     static_assert((std::is_same<std::underlying_type<F>::type, unsigned>::value),
                   "F has the wrong underlying type");
 
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::underlying_type_t<E>, int>::value), "");
+    static_assert((std::is_same<std::underlying_type_t<F>, unsigned>::value), "");
+#endif
+
 #if __has_feature(cxx_strong_enums)
     enum G : char { };
 
     static_assert((std::is_same<std::underlying_type<G>::type, char>::value),
                   "G has the wrong underlying type");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::underlying_type_t<G>, char>::value), "");
+#endif
 #endif // __has_feature(cxx_strong_enums)
 }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
index 42128251283..76d0f12d03f 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.ptr/add_pointer.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_add_pointer()
 {
     static_assert((std::is_same<typename std::add_pointer<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::add_pointer_t<T>,     U>::value), "");
+#endif
 }
 
 int main()
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
index ed09b03843d..9cecd39049f 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.ptr/remove_pointer.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_remove_pointer()
 {
     static_assert((std::is_same<typename std::remove_pointer<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::remove_pointer_t<T>,     U>::value), "");
+#endif
 }
 
 int main()
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
index eddbbe0d86d..8150ce04e37 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/add_lvalue_ref.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_add_lvalue_reference()
 {
     static_assert((std::is_same<typename std::add_lvalue_reference<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::add_lvalue_reference_t<T>, U>::value), "");
+#endif
 }
 
 int main()
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
index 925385190c7..e8f08fdc398 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/add_rvalue_ref.pass.cpp
@@ -19,6 +19,9 @@ template <class T, class U>
 void test_add_rvalue_reference()
 {
     static_assert((std::is_same<typename std::add_rvalue_reference<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::add_rvalue_reference_t<T>, U>::value), "");
+#endif
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
index 8d837bb1b00..f9ebc37a5dd 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.ref/remove_ref.pass.cpp
@@ -17,6 +17,9 @@ template <class T, class U>
 void test_remove_reference()
 {
     static_assert((std::is_same<typename std::remove_reference<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::remove_reference_t<T>, U>::value), "");
+#endif
 }
 
 int main()
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
index 936ed865c11..8acc01a1b69 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp
@@ -21,22 +21,30 @@ enum BigEnum
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
+template <class T, class U>
+void test_make_signed()
+{
+    static_assert((std::is_same<typename std::make_signed<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::make_signed_t<T>, U>::value), "");
+#endif
+}
+
 int main()
 {
-    static_assert((std::is_same<std::make_signed<signed char>::type, signed char>::value), "");
-    static_assert((std::is_same<std::make_signed<unsigned char>::type, signed char>::value), "");
-    static_assert((std::is_same<std::make_signed<char>::type, signed char>::value), "");
-    static_assert((std::is_same<std::make_signed<short>::type, signed short>::value), "");
-    static_assert((std::is_same<std::make_signed<unsigned short>::type, signed short>::value), "");
-    static_assert((std::is_same<std::make_signed<int>::type, signed int>::value), "");
-    static_assert((std::is_same<std::make_signed<unsigned int>::type, signed int>::value), "");
-    static_assert((std::is_same<std::make_signed<long>::type, signed long>::value), "");
-    static_assert((std::is_same<std::make_signed<unsigned long>::type, long>::value), "");
-    static_assert((std::is_same<std::make_signed<long long>::type, signed long long>::value), "");
-    static_assert((std::is_same<std::make_signed<unsigned long long>::type, signed long long>::value), "");
-    static_assert((std::is_same<std::make_signed<wchar_t>::type, int>::value), "");
-    static_assert((std::is_same<std::make_signed<const wchar_t>::type, const int>::value), "");
-    static_assert((std::is_same<std::make_signed<const Enum>::type, const int>::value), "");
-    static_assert((std::is_same<std::make_signed<BigEnum>::type,
-                   std::conditional<sizeof(long) == 4, long long, long>::type>::value), "");
+    test_make_signed< signed char, signed char >();
+    test_make_signed< unsigned char, signed char >();
+    test_make_signed< char, signed char >();
+    test_make_signed< short, signed short >();
+    test_make_signed< unsigned short, signed short >();
+    test_make_signed< int, signed int >();
+    test_make_signed< unsigned int, signed int >();
+    test_make_signed< long, signed long >();
+    test_make_signed< unsigned long, long >();
+    test_make_signed< long long, signed long long >();
+    test_make_signed< unsigned long long, signed long long >();
+    test_make_signed< wchar_t, int >();
+    test_make_signed< const wchar_t, const int >();
+    test_make_signed< const Enum, const int >();
+    test_make_signed< BigEnum, std::conditional<sizeof(long) == 4, long long, long>::type >();
 }
diff --git a/libcxx/test/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp b/libcxx/test/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
index dcea01c7fa1..492e01fba02 100644
--- a/libcxx/test/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp
@@ -21,22 +21,31 @@ enum BigEnum
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
+template <class T, class U>
+void test_make_unsigned()
+{
+    static_assert((std::is_same<typename std::make_unsigned<T>::type, U>::value), "");
+#if _LIBCPP_STD_VER > 11
+    static_assert((std::is_same<std::make_unsigned_t<T>, U>::value), "");
+#endif
+}
+
 int main()
 {
-    static_assert((std::is_same<std::make_unsigned<signed char>::type, unsigned char>::value), "");
-    static_assert((std::is_same<std::make_unsigned<unsigned char>::type, unsigned char>::value), "");
-    static_assert((std::is_same<std::make_unsigned<char>::type, unsigned char>::value), "");
-    static_assert((std::is_same<std::make_unsigned<short>::type, unsigned short>::value), "");
-    static_assert((std::is_same<std::make_unsigned<unsigned short>::type, unsigned short>::value), "");
-    static_assert((std::is_same<std::make_unsigned<int>::type, unsigned int>::value), "");
-    static_assert((std::is_same<std::make_unsigned<unsigned int>::type, unsigned int>::value), "");
-    static_assert((std::is_same<std::make_unsigned<long>::type, unsigned long>::value), "");
-    static_assert((std::is_same<std::make_unsigned<unsigned long>::type, unsigned long>::value), "");
-    static_assert((std::is_same<std::make_unsigned<long long>::type, unsigned long long>::value), "");
-    static_assert((std::is_same<std::make_unsigned<unsigned long long>::type, unsigned long long>::value), "");
-    static_assert((std::is_same<std::make_unsigned<wchar_t>::type, unsigned int>::value), "");
-    static_assert((std::is_same<std::make_unsigned<const wchar_t>::type, const unsigned int>::value), "");
-    static_assert((std::is_same<std::make_unsigned<const Enum>::type, const unsigned int>::value), "");
-    static_assert((std::is_same<std::make_unsigned<BigEnum>::type,
-                   std::conditional<sizeof(long) == 4, unsigned long long, unsigned long>::type>::value), "");
+    test_make_unsigned<signed char, unsigned char> ();
+    test_make_unsigned<unsigned char, unsigned char> ();
+    test_make_unsigned<char, unsigned char> ();
+    test_make_unsigned<short, unsigned short> ();
+    test_make_unsigned<unsigned short, unsigned short> ();
+    test_make_unsigned<int, unsigned int> ();
+    test_make_unsigned<unsigned int, unsigned int> ();
+    test_make_unsigned<long, unsigned long> ();
+    test_make_unsigned<unsigned long, unsigned long> ();
+    test_make_unsigned<long long, unsigned long long> ();
+    test_make_unsigned<unsigned long long, unsigned long long> ();
+    test_make_unsigned<wchar_t, unsigned int> ();
+    test_make_unsigned<const wchar_t, const unsigned int> ();
+    test_make_unsigned<const Enum, const unsigned int> ();
+    test_make_unsigned<BigEnum,
+                   std::conditional<sizeof(long) == 4, unsigned long long, unsigned long>::type> ();
 }