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

llvm-svn: 185597

48 files changed, 963 insertions, 591 deletions

diff --git a/libcxx/test/utilities/meta/meta.rel/is_convertible.pass.cpp b/libcxx/test/utilities/meta/meta.rel/is_convertible.pass.cpp
index e0728543902..37daa46001a 100644
--- a/libcxx/test/utilities/meta/meta.rel/is_convertible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.rel/is_convertible.pass.cpp
@@ -13,6 +13,24 @@
 
 #include <type_traits>
 
+template <class T, class U>
+void test_is_convertible()
+{
+    static_assert((std::is_convertible<T, U>::value), "");
+    static_assert((std::is_convertible<const T, U>::value), "");
+    static_assert((std::is_convertible<T, const U>::value), "");
+    static_assert((std::is_convertible<const T, const U>::value), "");
+}
+
+template <class T, class U>
+void test_is_not_convertible()
+{
+    static_assert((!std::is_convertible<T, U>::value), "");
+    static_assert((!std::is_convertible<const T, U>::value), "");
+    static_assert((!std::is_convertible<T, const U>::value), "");
+    static_assert((!std::is_convertible<const T, const U>::value), "");
+}
+
 typedef void Function();
 typedef char Array[1];
 
@@ -22,353 +40,143 @@ class NonCopyable {
 
 int main()
 {
-    {
-    static_assert(( std::is_convertible<void, void>::value), "");
-    static_assert(( std::is_convertible<const void, void>::value), "");
-    static_assert(( std::is_convertible<void, const void>::value), "");
-    static_assert(( std::is_convertible<const void, const void>::value), "");
-
-    static_assert((!std::is_convertible<void, Function>::value), "");
-    static_assert((!std::is_convertible<const void, Function>::value), "");
-
-    static_assert((!std::is_convertible<void, Function&>::value), "");
-    static_assert((!std::is_convertible<const void, Function&>::value), "");
-
-    static_assert((!std::is_convertible<void, Function*>::value), "");
-    static_assert((!std::is_convertible<void, Function* const>::value), "");
-    static_assert((!std::is_convertible<const void, Function*>::value), "");
-    static_assert((!std::is_convertible<const void, Function*const >::value), "");
-
-    static_assert((!std::is_convertible<void, Array>::value), "");
-    static_assert((!std::is_convertible<void, const Array>::value), "");
-    static_assert((!std::is_convertible<const void, Array>::value), "");
-    static_assert((!std::is_convertible<const void, const Array>::value), "");
-
-    static_assert((!std::is_convertible<void, Array&>::value), "");
-    static_assert((!std::is_convertible<void, const Array&>::value), "");
-    static_assert((!std::is_convertible<const void, Array&>::value), "");
-    static_assert((!std::is_convertible<const void, const Array&>::value), "");
-
-    static_assert((!std::is_convertible<void, char>::value), "");
-    static_assert((!std::is_convertible<void, const char>::value), "");
-    static_assert((!std::is_convertible<const void, char>::value), "");
-    static_assert((!std::is_convertible<const void, const char>::value), "");
-
-    static_assert((!std::is_convertible<void, char&>::value), "");
-    static_assert((!std::is_convertible<void, const char&>::value), "");
-    static_assert((!std::is_convertible<const void, char&>::value), "");
-    static_assert((!std::is_convertible<const void, const char&>::value), "");
-
-    static_assert((!std::is_convertible<void, char*>::value), "");
-    static_assert((!std::is_convertible<void, const char*>::value), "");
-    static_assert((!std::is_convertible<const void, char*>::value), "");
-    static_assert((!std::is_convertible<const void, const char*>::value), "");
-    }
-    {
-    static_assert((!std::is_convertible<Function, void>::value), "");
-    static_assert((!std::is_convertible<Function, const void>::value), "");
-
-    static_assert((!std::is_convertible<Function, Function>::value), "");
-
-    static_assert(( std::is_convertible<Function, Function&>::value), "");
-
-    static_assert(( std::is_convertible<Function, Function*>::value), "");
-    static_assert(( std::is_convertible<Function, Function* const>::value), "");
-
-    static_assert((!std::is_convertible<Function, Array>::value), "");
-    static_assert((!std::is_convertible<Function, const Array>::value), "");
-
-    static_assert((!std::is_convertible<Function, Array&>::value), "");
-    static_assert((!std::is_convertible<Function, const Array&>::value), "");
-
-    static_assert((!std::is_convertible<Function, char>::value), "");
-    static_assert((!std::is_convertible<Function, const char>::value), "");
-
-    static_assert((!std::is_convertible<Function, char&>::value), "");
-    static_assert((!std::is_convertible<Function, const char&>::value), "");
-
-    static_assert((!std::is_convertible<Function, char*>::value), "");
-    static_assert((!std::is_convertible<Function, const char*>::value), "");
-    }
-    {
-    static_assert((!std::is_convertible<Function&, void>::value), "");
-    static_assert((!std::is_convertible<Function&, const void>::value), "");
-
-    static_assert((!std::is_convertible<Function&, Function>::value), "");
-
-    static_assert(( std::is_convertible<Function&, Function&>::value), "");
-
-    static_assert(( std::is_convertible<Function&, Function*>::value), "");
-    static_assert(( std::is_convertible<Function&, Function* const>::value), "");
-
-    static_assert((!std::is_convertible<Function&, Array>::value), "");
-    static_assert((!std::is_convertible<Function&, const Array>::value), "");
-
-    static_assert((!std::is_convertible<Function&, Array&>::value), "");
-    static_assert((!std::is_convertible<Function&, const Array&>::value), "");
-
-    static_assert((!std::is_convertible<Function&, char>::value), "");
-    static_assert((!std::is_convertible<Function&, const char>::value), "");
-
-    static_assert((!std::is_convertible<Function&, char&>::value), "");
-    static_assert((!std::is_convertible<Function&, const char&>::value), "");
-
-    static_assert((!std::is_convertible<Function&, char*>::value), "");
-    static_assert((!std::is_convertible<Function&, const char*>::value), "");
-    }
-    {
-    static_assert((!std::is_convertible<Function*, void>::value), "");
-    static_assert((!std::is_convertible<Function*const, void>::value), "");
-    static_assert((!std::is_convertible<Function*, const void>::value), "");
-    static_assert((!std::is_convertible<Function*const, const void>::value), "");
-
-    static_assert((!std::is_convertible<Function*, Function>::value), "");
-    static_assert((!std::is_convertible<Function*const, Function>::value), "");
-
-    static_assert((!std::is_convertible<Function*, Function&>::value), "");
-    static_assert((!std::is_convertible<Function*const, Function&>::value), "");
-
-    static_assert(( std::is_convertible<Function*, Function*>::value), "");
-    static_assert(( std::is_convertible<Function*, Function* const>::value), "");
-    static_assert(( std::is_convertible<Function*const, Function*>::value), "");
-    static_assert(( std::is_convertible<Function*const, Function*const >::value), "");
-
-    static_assert((!std::is_convertible<Function*, Array>::value), "");
-    static_assert((!std::is_convertible<Function*, const Array>::value), "");
-    static_assert((!std::is_convertible<Function*const, Array>::value), "");
-    static_assert((!std::is_convertible<Function*const, const Array>::value), "");
-
-    static_assert((!std::is_convertible<Function*, Array&>::value), "");
-    static_assert((!std::is_convertible<Function*, const Array&>::value), "");
-    static_assert((!std::is_convertible<Function*const, Array&>::value), "");
-    static_assert((!std::is_convertible<Function*const, const Array&>::value), "");
-
-    static_assert((!std::is_convertible<Function*, char>::value), "");
-    static_assert((!std::is_convertible<Function*, const char>::value), "");
-    static_assert((!std::is_convertible<Function*const, char>::value), "");
-    static_assert((!std::is_convertible<Function*const, const char>::value), "");
-
-    static_assert((!std::is_convertible<Function*, char&>::value), "");
-    static_assert((!std::is_convertible<Function*, const char&>::value), "");
-    static_assert((!std::is_convertible<Function*const, char&>::value), "");
-    static_assert((!std::is_convertible<Function*const, const char&>::value), "");
-
-    static_assert((!std::is_convertible<Function*, char*>::value), "");
-    static_assert((!std::is_convertible<Function*, const char*>::value), "");
-    static_assert((!std::is_convertible<Function*const, char*>::value), "");
-    static_assert((!std::is_convertible<Function*const, const char*>::value), "");
-    }
-    {
-    static_assert((!std::is_convertible<Array, void>::value), "");
-    static_assert((!std::is_convertible<const Array, void>::value), "");
-    static_assert((!std::is_convertible<Array, const void>::value), "");
-    static_assert((!std::is_convertible<const Array, const void>::value), "");
-
-    static_assert((!std::is_convertible<Array, Function>::value), "");
-    static_assert((!std::is_convertible<const Array, Function>::value), "");
-
-    static_assert((!std::is_convertible<Array, Function&>::value), "");
-    static_assert((!std::is_convertible<const Array, Function&>::value), "");
-
-    static_assert((!std::is_convertible<Array, Function*>::value), "");
-    static_assert((!std::is_convertible<Array, Function* const>::value), "");
-    static_assert((!std::is_convertible<const Array, Function*>::value), "");
-    static_assert((!std::is_convertible<const Array, Function*const >::value), "");
-
-    static_assert((!std::is_convertible<Array, Array>::value), "");
-    static_assert((!std::is_convertible<Array, const Array>::value), "");
-    static_assert((!std::is_convertible<const Array, Array>::value), "");
-    static_assert((!std::is_convertible<const Array, const Array>::value), "");
+    // void
+    test_is_convertible<void,void> ();
+    test_is_not_convertible<void,Function> ();
+    test_is_not_convertible<void,Function&> ();
+    test_is_not_convertible<void,Function*> ();
+    test_is_not_convertible<void,Array> ();
+    test_is_not_convertible<void,Array&> ();
+    test_is_not_convertible<void,char> ();
+    test_is_not_convertible<void,char&> ();
+    test_is_not_convertible<void,char*> ();
+
+    // Function
+    test_is_not_convertible<Function, void> ();
+    test_is_not_convertible<Function, Function> ();
+    test_is_convertible<Function, Function&> ();
+    test_is_convertible<Function, Function*> ();
+    test_is_not_convertible<Function, Array> ();
+    test_is_not_convertible<Function, Array&> ();
+    test_is_not_convertible<Function, char> ();
+    test_is_not_convertible<Function, char&> ();
+    test_is_not_convertible<Function, char*> ();
+
+    // Function&
+    test_is_not_convertible<Function&, void> ();
+    test_is_not_convertible<Function&, Function> ();
+    test_is_convertible<Function&, Function&> ();
+
+    test_is_convertible<Function&, Function*> ();
+    test_is_not_convertible<Function&, Array> ();
+    test_is_not_convertible<Function&, Array&> ();
+    test_is_not_convertible<Function&, char> ();
+    test_is_not_convertible<Function&, char&> ();
+    test_is_not_convertible<Function&, char*> ();
+
+    // Function*
+    test_is_not_convertible<Function*, void> ();
+    test_is_not_convertible<Function*, Function> ();
+    test_is_not_convertible<Function*, Function&> ();
+    test_is_convertible<Function*, Function*> ();
+
+    test_is_not_convertible<Function*, Array> ();
+    test_is_not_convertible<Function*, Array&> ();
+    test_is_not_convertible<Function*, char> ();
+    test_is_not_convertible<Function*, char&> ();
+    test_is_not_convertible<Function*, char*> ();
+
+    // Array
+    test_is_not_convertible<Array, void> ();
+    test_is_not_convertible<Array, Function> ();
+    test_is_not_convertible<Array, Function&> ();
+    test_is_not_convertible<Array, Function*> ();
+    test_is_not_convertible<Array, Array> ();
 
     static_assert((!std::is_convertible<Array, Array&>::value), "");
     static_assert(( std::is_convertible<Array, const Array&>::value), "");
     static_assert((!std::is_convertible<const Array, Array&>::value), "");
     static_assert(( std::is_convertible<const Array, const Array&>::value), "");
 
-    static_assert((!std::is_convertible<Array, char>::value), "");
-    static_assert((!std::is_convertible<Array, const char>::value), "");
-    static_assert((!std::is_convertible<const Array, char>::value), "");
-    static_assert((!std::is_convertible<const Array, const char>::value), "");
-
-    static_assert((!std::is_convertible<Array, char&>::value), "");
-    static_assert((!std::is_convertible<Array, const char&>::value), "");
-    static_assert((!std::is_convertible<const Array, char&>::value), "");
-    static_assert((!std::is_convertible<const Array, const char&>::value), "");
+    test_is_not_convertible<Array, char> ();
+    test_is_not_convertible<Array, char&> ();
 
     static_assert(( std::is_convertible<Array, char*>::value), "");
     static_assert(( std::is_convertible<Array, const char*>::value), "");
     static_assert((!std::is_convertible<const Array, char*>::value), "");
     static_assert(( std::is_convertible<const Array, const char*>::value), "");
-    }
-    {
-    static_assert((!std::is_convertible<Array&, void>::value), "");
-    static_assert((!std::is_convertible<const Array&, void>::value), "");
-    static_assert((!std::is_convertible<Array&, const void>::value), "");
-    static_assert((!std::is_convertible<const Array&, const void>::value), "");
-
-    static_assert((!std::is_convertible<Array&, Function>::value), "");
-    static_assert((!std::is_convertible<const Array&, Function>::value), "");
 
-    static_assert((!std::is_convertible<Array&, Function&>::value), "");
-    static_assert((!std::is_convertible<const Array&, Function&>::value), "");
-
-    static_assert((!std::is_convertible<Array&, Function*>::value), "");
-    static_assert((!std::is_convertible<Array&, Function* const>::value), "");
-    static_assert((!std::is_convertible<const Array&, Function*>::value), "");
-    static_assert((!std::is_convertible<const Array&, Function*const >::value), "");
-
-    static_assert((!std::is_convertible<Array&, Array>::value), "");
-    static_assert((!std::is_convertible<Array&, const Array>::value), "");
-    static_assert((!std::is_convertible<const Array&, Array>::value), "");
-    static_assert((!std::is_convertible<const Array&, const Array>::value), "");
+    // Array&
+    test_is_not_convertible<Array&, void> ();
+    test_is_not_convertible<Array&, Function> ();
+    test_is_not_convertible<Array&, Function&> ();
+    test_is_not_convertible<Array&, Function*> ();
+    test_is_not_convertible<Array&, Array> ();
 
     static_assert(( std::is_convertible<Array&, Array&>::value), "");
     static_assert(( std::is_convertible<Array&, const Array&>::value), "");
     static_assert((!std::is_convertible<const Array&, Array&>::value), "");
     static_assert(( std::is_convertible<const Array&, const Array&>::value), "");
 
-    static_assert((!std::is_convertible<Array&, char>::value), "");
-    static_assert((!std::is_convertible<Array&, const char>::value), "");
-    static_assert((!std::is_convertible<const Array&, char>::value), "");
-    static_assert((!std::is_convertible<const Array&, const char>::value), "");
-
-    static_assert((!std::is_convertible<Array&, char&>::value), "");
-    static_assert((!std::is_convertible<Array&, const char&>::value), "");
-    static_assert((!std::is_convertible<const Array&, char&>::value), "");
-    static_assert((!std::is_convertible<const Array&, const char&>::value), "");
+    test_is_not_convertible<Array&, char> ();
+    test_is_not_convertible<Array&, char&> ();
 
     static_assert(( std::is_convertible<Array&, char*>::value), "");
     static_assert(( std::is_convertible<Array&, const char*>::value), "");
     static_assert((!std::is_convertible<const Array&, char*>::value), "");
     static_assert(( std::is_convertible<const Array&, const char*>::value), "");
-    }
-    {
-    static_assert((!std::is_convertible<char, void>::value), "");
-    static_assert((!std::is_convertible<const char, void>::value), "");
-    static_assert((!std::is_convertible<char, const void>::value), "");
-    static_assert((!std::is_convertible<const char, const void>::value), "");
-
-    static_assert((!std::is_convertible<char, Function>::value), "");
-    static_assert((!std::is_convertible<const char, Function>::value), "");
 
-    static_assert((!std::is_convertible<char, Function&>::value), "");
-    static_assert((!std::is_convertible<const char, Function&>::value), "");
-
-    static_assert((!std::is_convertible<char, Function*>::value), "");
-    static_assert((!std::is_convertible<char, Function* const>::value), "");
-    static_assert((!std::is_convertible<const char, Function*>::value), "");
-    static_assert((!std::is_convertible<const char, Function*const >::value), "");
-
-    static_assert((!std::is_convertible<char, Array>::value), "");
-    static_assert((!std::is_convertible<char, const Array>::value), "");
-    static_assert((!std::is_convertible<const char, Array>::value), "");
-    static_assert((!std::is_convertible<const char, const Array>::value), "");
-
-    static_assert((!std::is_convertible<char, Array&>::value), "");
-    static_assert((!std::is_convertible<char, const Array&>::value), "");
-    static_assert((!std::is_convertible<const char, Array&>::value), "");
-    static_assert((!std::is_convertible<const char, const Array&>::value), "");
-
-    static_assert(( std::is_convertible<char, char>::value), "");
-    static_assert(( std::is_convertible<char, const char>::value), "");
-    static_assert(( std::is_convertible<const char, char>::value), "");
-    static_assert(( std::is_convertible<const char, const char>::value), "");
+    // char
+    test_is_not_convertible<char, void> ();
+    test_is_not_convertible<char, Function> ();
+    test_is_not_convertible<char, Function&> ();
+    test_is_not_convertible<char, Function*> ();
+    test_is_not_convertible<char, Array> ();
+    test_is_not_convertible<char, Array&> ();
 
+	test_is_convertible<char, char> ();
+	
     static_assert((!std::is_convertible<char, char&>::value), "");
     static_assert(( std::is_convertible<char, const char&>::value), "");
     static_assert((!std::is_convertible<const char, char&>::value), "");
     static_assert(( std::is_convertible<const char, const char&>::value), "");
 
-    static_assert((!std::is_convertible<char, char*>::value), "");
-    static_assert((!std::is_convertible<char, const char*>::value), "");
-    static_assert((!std::is_convertible<const char, char*>::value), "");
-    static_assert((!std::is_convertible<const char, const char*>::value), "");
-    }
-    {
-    static_assert((!std::is_convertible<char&, void>::value), "");
-    static_assert((!std::is_convertible<const char&, void>::value), "");
-    static_assert((!std::is_convertible<char&, const void>::value), "");
-    static_assert((!std::is_convertible<const char&, const void>::value), "");
-
-    static_assert((!std::is_convertible<char&, Function>::value), "");
-    static_assert((!std::is_convertible<const char&, Function>::value), "");
-
-    static_assert((!std::is_convertible<char&, Function&>::value), "");
-    static_assert((!std::is_convertible<const char&, Function&>::value), "");
-
-    static_assert((!std::is_convertible<char&, Function*>::value), "");
-    static_assert((!std::is_convertible<char&, Function* const>::value), "");
-    static_assert((!std::is_convertible<const char&, Function*>::value), "");
-    static_assert((!std::is_convertible<const char&, Function*const >::value), "");
-
-    static_assert((!std::is_convertible<char&, Array>::value), "");
-    static_assert((!std::is_convertible<char&, const Array>::value), "");
-    static_assert((!std::is_convertible<const char&, Array>::value), "");
-    static_assert((!std::is_convertible<const char&, const Array>::value), "");
+    test_is_not_convertible<char, char*> ();
 
-    static_assert((!std::is_convertible<char&, Array&>::value), "");
-    static_assert((!std::is_convertible<char&, const Array&>::value), "");
-    static_assert((!std::is_convertible<const char&, Array&>::value), "");
-    static_assert((!std::is_convertible<const char&, const Array&>::value), "");
-
-    static_assert(( std::is_convertible<char&, char>::value), "");
-    static_assert(( std::is_convertible<char&, const char>::value), "");
-    static_assert(( std::is_convertible<const char&, char>::value), "");
-    static_assert(( std::is_convertible<const char&, const char>::value), "");
+    // char&
+    test_is_not_convertible<char&, void> ();
+    test_is_not_convertible<char&, Function> ();
+    test_is_not_convertible<char&, Function&> ();
+    test_is_not_convertible<char&, Function*> ();
+    test_is_not_convertible<char&, Array> ();
+    test_is_not_convertible<char&, Array&> ();
 
+	test_is_convertible<char&, char> ();
+	
     static_assert(( std::is_convertible<char&, char&>::value), "");
     static_assert(( std::is_convertible<char&, const char&>::value), "");
     static_assert((!std::is_convertible<const char&, char&>::value), "");
     static_assert(( std::is_convertible<const char&, const char&>::value), "");
 
-    static_assert((!std::is_convertible<char&, char*>::value), "");
-    static_assert((!std::is_convertible<char&, const char*>::value), "");
-    static_assert((!std::is_convertible<const char&, char*>::value), "");
-    static_assert((!std::is_convertible<const char&, const char*>::value), "");
-    }
-    {
-    static_assert((!std::is_convertible<char*, void>::value), "");
-    static_assert((!std::is_convertible<const char*, void>::value), "");
-    static_assert((!std::is_convertible<char*, const void>::value), "");
-    static_assert((!std::is_convertible<const char*, const void>::value), "");
-
-    static_assert((!std::is_convertible<char*, Function>::value), "");
-    static_assert((!std::is_convertible<const char*, Function>::value), "");
-
-    static_assert((!std::is_convertible<char*, Function&>::value), "");
-    static_assert((!std::is_convertible<const char*, Function&>::value), "");
-
-    static_assert((!std::is_convertible<char*, Function*>::value), "");
-    static_assert((!std::is_convertible<char*, Function* const>::value), "");
-    static_assert((!std::is_convertible<const char*, Function*>::value), "");
-    static_assert((!std::is_convertible<const char*, Function*const >::value), "");
+    test_is_not_convertible<char&, char*> ();
 
-    static_assert((!std::is_convertible<char*, Array>::value), "");
-    static_assert((!std::is_convertible<char*, const Array>::value), "");
-    static_assert((!std::is_convertible<const char*, Array>::value), "");
-    static_assert((!std::is_convertible<const char*, const Array>::value), "");
-
-    static_assert((!std::is_convertible<char*, Array&>::value), "");
-    static_assert((!std::is_convertible<char*, const Array&>::value), "");
-    static_assert((!std::is_convertible<const char*, Array&>::value), "");
-    static_assert((!std::is_convertible<const char*, const Array&>::value), "");
-
-    static_assert((!std::is_convertible<char*, char>::value), "");
-    static_assert((!std::is_convertible<char*, const char>::value), "");
-    static_assert((!std::is_convertible<const char*, char>::value), "");
-    static_assert((!std::is_convertible<const char*, const char>::value), "");
-
-    static_assert((!std::is_convertible<char*, char&>::value), "");
-    static_assert((!std::is_convertible<char*, const char&>::value), "");
-    static_assert((!std::is_convertible<const char*, char&>::value), "");
-    static_assert((!std::is_convertible<const char*, const char&>::value), "");
+    // char*
+    test_is_not_convertible<char*, void> ();
+    test_is_not_convertible<char*, Function> ();
+    test_is_not_convertible<char*, Function&> ();
+    test_is_not_convertible<char*, Function*> ();
+    test_is_not_convertible<char*, Array> ();
+    test_is_not_convertible<char*, Array&> ();
 
+	test_is_not_convertible<char*, char> ();
+	test_is_not_convertible<char*, char&> ();
+	
     static_assert(( std::is_convertible<char*, char*>::value), "");
     static_assert(( std::is_convertible<char*, const char*>::value), "");
     static_assert((!std::is_convertible<const char*, char*>::value), "");
     static_assert(( std::is_convertible<const char*, const char*>::value), "");
-    }
-    {
+
+    // NonCopyable
     static_assert((std::is_convertible<NonCopyable&, NonCopyable&>::value), "");
     static_assert((std::is_convertible<NonCopyable&, const NonCopyable&>::value), "");
     static_assert((std::is_convertible<NonCopyable&, const volatile NonCopyable&>::value), "");
@@ -378,5 +186,4 @@ int main()
     static_assert((std::is_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value), "");
     static_assert((std::is_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value), "");
     static_assert((!std::is_convertible<const NonCopyable&, NonCopyable&>::value), "");
-    }
 }
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> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
index 9bae2cd712b..7563c2fd585 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.comp/rvalue_ref.pass.cpp
@@ -16,7 +16,7 @@
 template <class T>
 void test_rvalue_ref()
 {
-    static_assert(std::is_reference<T>::value, "");
+    static_assert( std::is_reference<T>::value, "");
     static_assert(!std::is_arithmetic<T>::value, "");
     static_assert(!std::is_fundamental<T>::value, "");
     static_assert(!std::is_object<T>::value, "");
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
index e37987c54c5..8c21c759fa1 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
@@ -22,17 +22,32 @@ struct B
     void operator=(A);
 };
 
+template <class T, class U>
+void test_is_assignable()
+{
+    static_assert(( std::is_assignable<T, U>::value), "");
+}
+
+template <class T, class U>
+void test_is_not_assignable()
+{
+    static_assert((!std::is_assignable<T, U>::value), "");
+}
+
 int main()
 {
-    static_assert(( std::is_assignable<int&, int&>::value), "");
-    static_assert(( std::is_assignable<int&, int>::value), "");
-    static_assert((!std::is_assignable<int, int&>::value), "");
-    static_assert((!std::is_assignable<int, int>::value), "");
-    static_assert(( std::is_assignable<int&, double>::value), "");
-    static_assert(( std::is_assignable<B, A>::value), "");
-    static_assert((!std::is_assignable<A, B>::value), "");
-    static_assert((!std::is_assignable<void, const void>::value), "");
-    static_assert((!std::is_assignable<const void, const void>::value), "");
-    static_assert(( std::is_assignable<void*&, void*>::value), "");
-    static_assert((!std::is_assignable<int(), int>::value), "");
+    test_is_assignable<int&, int&> ();
+    test_is_assignable<int&, int> ();
+    test_is_assignable<int&, double> ();
+    test_is_assignable<B, A> ();
+    test_is_assignable<void*&, void*> ();
+
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    test_is_not_assignable<int, int&> ();
+    test_is_not_assignable<int, int> ();
+#endif
+    test_is_not_assignable<A, B> ();
+    test_is_not_assignable<void, const void> ();
+    test_is_not_assignable<const void, const void> ();
+    test_is_not_assignable<int(), int> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
index 6f58adc5077..0753ab7bcaa 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
@@ -18,20 +18,57 @@ struct A
 {
     explicit A(int);
     A(int, double);
+#if __has_feature(cxx_access_control_sfinae) 
 private:
+#endif
     A(char);
 };
 
+template <class T>
+void test_is_constructible()
+{
+    static_assert( (std::is_constructible<T>::value), "");
+}
+
+template <class T, class A0>
+void test_is_constructible()
+{
+    static_assert( (std::is_constructible<T, A0>::value), "");
+}
+
+template <class T, class A0, class A1>
+void test_is_constructible()
+{
+    static_assert( (std::is_constructible<T, A0, A1>::value), "");
+}
+
+template <class T>
+void test_is_not_constructible()
+{
+    static_assert((!std::is_constructible<T>::value), "");
+}
+
+template <class T, class A0>
+void test_is_not_constructible()
+{
+    static_assert((!std::is_constructible<T, A0>::value), "");
+}
+
 int main()
 {
-    static_assert((std::is_constructible<int>::value), "");
-    static_assert((std::is_constructible<int, const int>::value), "");
-    static_assert((std::is_constructible<A, int>::value), "");
-    static_assert((std::is_constructible<A, int, double>::value), "");
-    static_assert((!std::is_constructible<A>::value), "");
-    static_assert((!std::is_constructible<A, char>::value), "");
-    static_assert((!std::is_constructible<A, void>::value), "");
-    static_assert((!std::is_constructible<void>::value), "");
-    static_assert((!std::is_constructible<int&>::value), "");
-    static_assert(( std::is_constructible<int&, int&>::value), "");
+    test_is_constructible<int> ();
+    test_is_constructible<int, const int> ();
+    test_is_constructible<A, int> ();
+    test_is_constructible<A, int, double> ();
+    test_is_constructible<int&, int&> ();
+
+    test_is_not_constructible<A> ();
+#if __has_feature(cxx_access_control_sfinae) 
+    test_is_not_constructible<A, char> ();
+#else
+    test_is_constructible<A, char> ();
+#endif
+    test_is_not_constructible<A, void> ();
+    test_is_not_constructible<void> ();
+    test_is_not_constructible<int&> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
index 9f9acd191a5..bde44de4c25 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
@@ -13,6 +13,18 @@
 
 #include <type_traits>
 
+template <class T>
+void test_is_copy_assignable()
+{
+    static_assert(( std::is_copy_assignable<T>::value), "");
+}
+
+template <class T>
+void test_is_not_copy_assignable()
+{
+    static_assert((!std::is_copy_assignable<T>::value), "");
+}
+
 class Empty
 {
 };
@@ -42,16 +54,21 @@ class B
 
 int main()
 {
-    static_assert(( std::is_copy_assignable<int>::value), "");
-    static_assert((!std::is_copy_assignable<const int>::value), "");
-    static_assert((!std::is_copy_assignable<int[]>::value), "");
-    static_assert((!std::is_copy_assignable<int[3]>::value), "");
-    static_assert(( std::is_copy_assignable<int&>::value), "");
-    static_assert(( std::is_copy_assignable<A>::value), "");
-    static_assert(( std::is_copy_assignable<bit_zero>::value), "");
-    static_assert(( std::is_copy_assignable<Union>::value), "");
-    static_assert(( std::is_copy_assignable<NotEmpty>::value), "");
-    static_assert(( std::is_copy_assignable<Empty>::value), "");
-    static_assert((!std::is_copy_assignable<B>::value), "");
-    static_assert((!std::is_copy_assignable<void>::value), "");
+    test_is_copy_assignable<int> ();
+    test_is_copy_assignable<int&> ();
+    test_is_copy_assignable<A> ();
+    test_is_copy_assignable<bit_zero> ();
+    test_is_copy_assignable<Union> ();
+    test_is_copy_assignable<NotEmpty> ();
+    test_is_copy_assignable<Empty> ();
+
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    test_is_not_copy_assignable<const int> ();
+    test_is_not_copy_assignable<int[]> ();
+    test_is_not_copy_assignable<int[3]> ();
+#endif
+#if __has_feature(cxx_access_control_sfinae) 
+    test_is_not_copy_assignable<B> ();
+#endif
+    test_is_not_copy_assignable<void> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
index 1cfb76fa5a2..837d0b0d218 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
@@ -13,10 +13,16 @@
 
 #include <type_traits>
 
-template <class T, bool Result>
+template <class T>
 void test_is_copy_constructible()
 {
-    static_assert(std::is_copy_constructible<T>::value == Result, "");
+    static_assert( std::is_copy_constructible<T>::value, "");
+}
+
+template <class T>
+void test_is_not_copy_constructible()
+{
+    static_assert(!std::is_copy_constructible<T>::value, "");
 }
 
 class Empty
@@ -54,20 +60,22 @@ class B
 
 int main()
 {
-    test_is_copy_constructible<char[3], false>();
-    test_is_copy_constructible<char[], false>();
-    test_is_copy_constructible<void, false>();
-    test_is_copy_constructible<Abstract, false>();
+    test_is_copy_constructible<A>();
+    test_is_copy_constructible<int&>();
+    test_is_copy_constructible<Union>();
+    test_is_copy_constructible<Empty>();
+    test_is_copy_constructible<int>();
+    test_is_copy_constructible<double>();
+    test_is_copy_constructible<int*>();
+    test_is_copy_constructible<const int*>();
+    test_is_copy_constructible<NotEmpty>();
+    test_is_copy_constructible<bit_zero>();
 
-    test_is_copy_constructible<A, true>();
-    test_is_copy_constructible<B, false>();
-    test_is_copy_constructible<int&, true>();
-    test_is_copy_constructible<Union, true>();
-    test_is_copy_constructible<Empty, true>();
-    test_is_copy_constructible<int, true>();
-    test_is_copy_constructible<double, true>();
-    test_is_copy_constructible<int*, true>();
-    test_is_copy_constructible<const int*, true>();
-    test_is_copy_constructible<NotEmpty, true>();
-    test_is_copy_constructible<bit_zero, true>();
+    test_is_not_copy_constructible<char[3]>();
+    test_is_not_copy_constructible<char[]>();
+    test_is_not_copy_constructible<void>();
+    test_is_not_copy_constructible<Abstract>();
+#if __has_feature(cxx_access_control_sfinae) 
+    test_is_not_copy_constructible<B>();
+#endif
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
index 760a79b049e..379226a042b 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
@@ -13,13 +13,22 @@
 
 #include <type_traits>
 
-template <class T, bool Result>
+template <class T>
 void test_is_default_constructible()
 {
-    static_assert(std::is_default_constructible<T>::value == Result, "");
-    static_assert(std::is_default_constructible<const T>::value == Result, "");
-    static_assert(std::is_default_constructible<volatile T>::value == Result, "");
-    static_assert(std::is_default_constructible<const volatile T>::value == Result, "");
+    static_assert( std::is_default_constructible<T>::value, "");
+    static_assert( std::is_default_constructible<const T>::value, "");
+    static_assert( std::is_default_constructible<volatile T>::value, "");
+    static_assert( std::is_default_constructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_is_not_default_constructible()
+{
+    static_assert(!std::is_default_constructible<T>::value, "");
+    static_assert(!std::is_default_constructible<const T>::value, "");
+    static_assert(!std::is_default_constructible<volatile T>::value, "");
+    static_assert(!std::is_default_constructible<const volatile T>::value, "");
 }
 
 class Empty
@@ -57,20 +66,22 @@ class B
 
 int main()
 {
-    test_is_default_constructible<void, false>();
-    test_is_default_constructible<int&, false>();
-    test_is_default_constructible<char[], false>();
-    test_is_default_constructible<Abstract, false>();
+    test_is_default_constructible<A>();
+    test_is_default_constructible<Union>();
+    test_is_default_constructible<Empty>();
+    test_is_default_constructible<int>();
+    test_is_default_constructible<double>();
+    test_is_default_constructible<int*>();
+    test_is_default_constructible<const int*>();
+    test_is_default_constructible<char[3]>();
+    test_is_default_constructible<NotEmpty>();
+    test_is_default_constructible<bit_zero>();
 
-    test_is_default_constructible<A, true>();
-    test_is_default_constructible<B, false>();
-    test_is_default_constructible<Union, true>();
-    test_is_default_constructible<Empty, true>();
-    test_is_default_constructible<int, true>();
-    test_is_default_constructible<double, true>();
-    test_is_default_constructible<int*, true>();
-    test_is_default_constructible<const int*, true>();
-    test_is_default_constructible<char[3], true>();
-    test_is_default_constructible<NotEmpty, true>();
-    test_is_default_constructible<bit_zero, true>();
+    test_is_not_default_constructible<void>();
+    test_is_not_default_constructible<int&>();
+    test_is_not_default_constructible<char[]>();
+    test_is_not_default_constructible<Abstract>();
+#if __has_feature(cxx_access_control_sfinae) 
+    test_is_not_default_constructible<B>();
+#endif
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
index 61b04b2ab4a..cc7f75eb193 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
@@ -13,13 +13,22 @@
 
 #include <type_traits>
 
-template <class T, bool Result>
+template <class T>
 void test_is_destructible()
 {
-    static_assert( std::is_destructible<T>::value == Result, "");
-    static_assert( std::is_destructible<const T>::value == Result, "");
-    static_assert( std::is_destructible<volatile T>::value == Result, "");
-    static_assert( std::is_destructible<const volatile T>::value == Result, "");
+    static_assert( std::is_destructible<T>::value, "");
+    static_assert( std::is_destructible<const T>::value, "");
+    static_assert( std::is_destructible<volatile T>::value, "");
+    static_assert( std::is_destructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_is_not_destructible()
+{
+    static_assert(!std::is_destructible<T>::value, "");
+    static_assert(!std::is_destructible<const T>::value, "");
+    static_assert(!std::is_destructible<volatile T>::value, "");
+    static_assert(!std::is_destructible<const volatile T>::value, "");
 }
 
 class Empty
@@ -50,17 +59,20 @@ struct A
 
 int main()
 {
-    test_is_destructible<void, false>();
-    test_is_destructible<A, true>();
-    test_is_destructible<Abstract, false>();
-    test_is_destructible<NotEmpty, false>();
-    test_is_destructible<int&, true>();
-    test_is_destructible<Union, true>();
-    test_is_destructible<Empty, true>();
-    test_is_destructible<int, true>();
-    test_is_destructible<double, true>();
-    test_is_destructible<int*, true>();
-    test_is_destructible<const int*, true>();
-    test_is_destructible<char[3], true>();
-    test_is_destructible<bit_zero, true>();
+    test_is_destructible<A>();
+    test_is_destructible<int&>();
+    test_is_destructible<Union>();
+    test_is_destructible<Empty>();
+    test_is_destructible<int>();
+    test_is_destructible<double>();
+    test_is_destructible<int*>();
+    test_is_destructible<const int*>();
+    test_is_destructible<char[3]>();
+    test_is_destructible<bit_zero>();
+
+    test_is_not_destructible<void>();
+    test_is_not_destructible<Abstract>();
+#if __has_feature(cxx_access_control_sfinae) 
+    test_is_not_destructible<NotEmpty>();
+#endif
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
index 30e31ba5f53..ce781cd936b 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp
@@ -13,6 +13,18 @@
 
 #include <type_traits>
 
+template <class T>
+void test_is_literal_type()
+{
+    static_assert( std::is_literal_type<T>::value, "");
+}
+
+template <class T>
+void test_is_not_literal_type()
+{
+    static_assert(!std::is_literal_type<T>::value, "");
+}
+
 struct A
 {
 };
@@ -24,10 +36,11 @@ struct B
 
 int main()
 {
-    static_assert( std::is_literal_type<int>::value, "");
-    static_assert( std::is_literal_type<const int>::value, "");
-    static_assert( std::is_literal_type<int&>::value, "");
-    static_assert( std::is_literal_type<volatile int&>::value, "");
-    static_assert( std::is_literal_type<A>::value, "");
-    static_assert(!std::is_literal_type<B>::value, "");
+    test_is_literal_type<int> ();
+    test_is_literal_type<const int> ();
+    test_is_literal_type<int&> ();
+    test_is_literal_type<volatile int&> ();
+    test_is_literal_type<A> ();
+
+    test_is_not_literal_type<B> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
index 8941fe3e898..892ffd78f66 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
@@ -13,6 +13,18 @@
 
 #include <type_traits>
 
+template <class T>
+void test_is_move_assignable()
+{
+    static_assert( std::is_move_assignable<T>::value, "");
+}
+
+template <class T>
+void test_is_not_move_assignable()
+{
+    static_assert(!std::is_move_assignable<T>::value, "");
+}
+
 class Empty
 {
 };
@@ -37,15 +49,18 @@ struct A
 
 int main()
 {
-    static_assert(( std::is_move_assignable<int>::value), "");
-    static_assert((!std::is_move_assignable<const int>::value), "");
-    static_assert((!std::is_move_assignable<int[]>::value), "");
-    static_assert((!std::is_move_assignable<int[3]>::value), "");
-    static_assert((!std::is_move_assignable<int[3]>::value), "");
-    static_assert((!std::is_move_assignable<void>::value), "");
-    static_assert(( std::is_move_assignable<A>::value), "");
-    static_assert(( std::is_move_assignable<bit_zero>::value), "");
-    static_assert(( std::is_move_assignable<Union>::value), "");
-    static_assert(( std::is_move_assignable<NotEmpty>::value), "");
-    static_assert(( std::is_move_assignable<Empty>::value), "");
+    test_is_move_assignable<int> ();
+    test_is_move_assignable<A> ();
+    test_is_move_assignable<bit_zero> ();
+    test_is_move_assignable<Union> ();
+    test_is_move_assignable<NotEmpty> ();
+    test_is_move_assignable<Empty> ();
+
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    test_is_not_move_assignable<const int> ();
+    test_is_not_move_assignable<int[]> ();
+    test_is_not_move_assignable<int[3]> ();
+    test_is_not_move_assignable<int[3]> ();
+#endif
+    test_is_not_move_assignable<void> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
index 3ad3666a222..7409ebaa56c 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
@@ -13,10 +13,16 @@
 
 #include <type_traits>
 
-template <class T, bool Result>
+template <class T>
 void test_is_move_constructible()
 {
-    static_assert(std::is_move_constructible<T>::value == Result, "");
+    static_assert( std::is_move_constructible<T>::value, "");
+}
+
+template <class T>
+void test_is_not_move_constructible()
+{
+    static_assert(!std::is_move_constructible<T>::value, "");
 }
 
 class Empty
@@ -49,25 +55,27 @@ struct A
 
 struct B
 {
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     B(B&&);
+#endif
 };
 
 int main()
 {
-    test_is_move_constructible<char[3], false>();
-    test_is_move_constructible<char[], false>();
-    test_is_move_constructible<void, false>();
-    test_is_move_constructible<Abstract, false>();
+    test_is_not_move_constructible<char[3]>();
+    test_is_not_move_constructible<char[]>();
+    test_is_not_move_constructible<void>();
+    test_is_not_move_constructible<Abstract>();
 
-    test_is_move_constructible<A, true>();
-    test_is_move_constructible<int&, true>();
-    test_is_move_constructible<Union, true>();
-    test_is_move_constructible<Empty, true>();
-    test_is_move_constructible<int, true>();
-    test_is_move_constructible<double, true>();
-    test_is_move_constructible<int*, true>();
-    test_is_move_constructible<const int*, true>();
-    test_is_move_constructible<NotEmpty, true>();
-    test_is_move_constructible<bit_zero, true>();
-    test_is_move_constructible<B, true>();
+    test_is_move_constructible<A>();
+    test_is_move_constructible<int&>();
+    test_is_move_constructible<Union>();
+    test_is_move_constructible<Empty>();
+    test_is_move_constructible<int>();
+    test_is_move_constructible<double>();
+    test_is_move_constructible<int*>();
+    test_is_move_constructible<const int*>();
+    test_is_move_constructible<NotEmpty>();
+    test_is_move_constructible<bit_zero>();
+    test_is_move_constructible<B>();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
index b57115269c2..3bd2b3b7b80 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
@@ -13,6 +13,18 @@
 
 #include <type_traits>
 
+template <class T, class U>
+void test_is_nothrow_assignable()
+{
+    static_assert(( std::is_nothrow_assignable<T, U>::value), "");
+}
+
+template <class T, class U>
+void test_is_not_nothrow_assignable()
+{
+    static_assert((!std::is_nothrow_assignable<T, U>::value), "");
+}
+
 struct A
 {
 };
@@ -24,11 +36,14 @@ struct B
 
 int main()
 {
-    static_assert(( std::is_nothrow_assignable<int&, int&>::value), "");
-    static_assert(( std::is_nothrow_assignable<int&, int>::value), "");
-    static_assert((!std::is_nothrow_assignable<int, int&>::value), "");
-    static_assert((!std::is_nothrow_assignable<int, int>::value), "");
-    static_assert(( std::is_nothrow_assignable<int&, double>::value), "");
-    static_assert((!std::is_nothrow_assignable<B, A>::value), "");
-    static_assert((!std::is_nothrow_assignable<A, B>::value), "");
+    test_is_nothrow_assignable<int&, int&> ();
+    test_is_nothrow_assignable<int&, int> ();
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    test_is_nothrow_assignable<int&, double> ();
+#endif
+
+    test_is_not_nothrow_assignable<int, int&> ();
+    test_is_not_nothrow_assignable<int, int> ();
+    test_is_not_nothrow_assignable<B, A> ();
+    test_is_not_nothrow_assignable<A, B> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
index 5da776fa5f6..8978ec9af53 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
@@ -14,6 +14,36 @@
 
 #include <type_traits>
 
+template <class T>
+void test_is_nothrow_constructible()
+{
+    static_assert(( std::is_nothrow_constructible<T>::value), "");
+}
+
+template <class T, class A0>
+void test_is_nothrow_constructible()
+{
+    static_assert(( std::is_nothrow_constructible<T, A0>::value), "");
+}
+
+template <class T>
+void test_is_not_nothrow_constructible()
+{
+    static_assert((!std::is_nothrow_constructible<T>::value), "");
+}
+
+template <class T, class A0>
+void test_is_not_nothrow_constructible()
+{
+    static_assert((!std::is_nothrow_constructible<T, A0>::value), "");
+}
+
+template <class T, class A0, class A1>
+void test_is_not_nothrow_constructible()
+{
+    static_assert((!std::is_nothrow_constructible<T, A0, A1>::value), "");
+}
+
 class Empty
 {
 };
@@ -42,11 +72,12 @@ struct A
 
 int main()
 {
-    static_assert(( std::is_nothrow_constructible<int>::value), "");
-    static_assert(( std::is_nothrow_constructible<int, const int&>::value), "");
-    static_assert((!std::is_nothrow_constructible<A, int>::value), "");
-    static_assert((!std::is_nothrow_constructible<A, int, double>::value), "");
-    static_assert((!std::is_nothrow_constructible<A>::value), "");
-    static_assert(( std::is_nothrow_constructible<Empty>::value), "");
-    static_assert(( std::is_nothrow_constructible<Empty, const Empty&>::value), "");
+    test_is_nothrow_constructible<int> ();
+    test_is_nothrow_constructible<int, const int&> ();
+    test_is_nothrow_constructible<Empty> ();
+    test_is_nothrow_constructible<Empty, const Empty&> ();
+
+    test_is_not_nothrow_constructible<A, int> ();
+    test_is_not_nothrow_constructible<A, int, double> ();
+    test_is_not_nothrow_constructible<A> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
index 1436dd44de1..d843803cf21 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
@@ -13,10 +13,16 @@
 
 #include <type_traits>
 
-template <class T, bool Result>
+template <class T>
 void test_has_nothrow_assign()
 {
-    static_assert(std::is_nothrow_copy_assignable<T>::value == Result, "");
+    static_assert( std::is_nothrow_copy_assignable<T>::value, "");
+}
+
+template <class T>
+void test_has_not_nothrow_assign()
+{
+    static_assert(!std::is_nothrow_copy_assignable<T>::value, "");
 }
 
 class Empty
@@ -42,17 +48,18 @@ struct A
 
 int main()
 {
-    test_has_nothrow_assign<const int, false>();
-    test_has_nothrow_assign<void, false>();
-    test_has_nothrow_assign<A, false>();
-    test_has_nothrow_assign<int&, true>();
-
-    test_has_nothrow_assign<Union, true>();
-    test_has_nothrow_assign<Empty, true>();
-    test_has_nothrow_assign<int, true>();
-    test_has_nothrow_assign<double, true>();
-    test_has_nothrow_assign<int*, true>();
-    test_has_nothrow_assign<const int*, true>();
-    test_has_nothrow_assign<NotEmpty, true>();
-    test_has_nothrow_assign<bit_zero, true>();
+    test_has_nothrow_assign<int&>();
+    test_has_nothrow_assign<Union>();
+    test_has_nothrow_assign<Empty>();
+    test_has_nothrow_assign<int>();
+    test_has_nothrow_assign<double>();
+    test_has_nothrow_assign<int*>();
+    test_has_nothrow_assign<const int*>();
+    test_has_nothrow_assign<NotEmpty>();
+    test_has_nothrow_assign<bit_zero>();
+
+    test_has_not_nothrow_assign<const int>();
+    test_has_not_nothrow_assign<void>();
+    test_has_not_nothrow_assign<A>();
+
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
index 1833e69840d..a513d52f933 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
@@ -63,15 +63,23 @@ int main()
     test_has_not_nothrow_destructor<Abstract>();
     test_has_not_nothrow_destructor<NotEmpty>();
 
+#if __has_feature(cxx_noexcept)
     test_is_nothrow_destructible<A>();
+#endif
     test_is_nothrow_destructible<int&>();
+#if  __has_feature(cxx_unrestricted_unions) 
     test_is_nothrow_destructible<Union>();
+#endif
+#if __has_feature(cxx_access_control_sfinae)
     test_is_nothrow_destructible<Empty>();
+#endif
     test_is_nothrow_destructible<int>();
     test_is_nothrow_destructible<double>();
     test_is_nothrow_destructible<int*>();
     test_is_nothrow_destructible<const int*>();
     test_is_nothrow_destructible<char[3]>();
     test_is_nothrow_destructible<char[3]>();
+#if __has_feature(cxx_noexcept)
     test_is_nothrow_destructible<bit_zero>();
+#endif
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
index 96a4a32b37d..fe51e438864 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
@@ -13,10 +13,16 @@
 
 #include <type_traits>
 
-template <class T, bool Result>
+template <class T>
 void test_has_nothrow_assign()
 {
-    static_assert(std::is_nothrow_move_assignable<T>::value == Result, "");
+    static_assert( std::is_nothrow_move_assignable<T>::value, "");
+}
+
+template <class T>
+void test_has_not_nothrow_assign()
+{
+    static_assert(!std::is_nothrow_move_assignable<T>::value, "");
 }
 
 class Empty
@@ -42,16 +48,16 @@ struct A
 
 int main()
 {
-    test_has_nothrow_assign<void, false>();
-    test_has_nothrow_assign<A, false>();
-    test_has_nothrow_assign<int&, true>();
-
-    test_has_nothrow_assign<Union, true>();
-    test_has_nothrow_assign<Empty, true>();
-    test_has_nothrow_assign<int, true>();
-    test_has_nothrow_assign<double, true>();
-    test_has_nothrow_assign<int*, true>();
-    test_has_nothrow_assign<const int*, true>();
-    test_has_nothrow_assign<NotEmpty, true>();
-    test_has_nothrow_assign<bit_zero, true>();
+    test_has_nothrow_assign<int&>();
+    test_has_nothrow_assign<Union>();
+    test_has_nothrow_assign<Empty>();
+    test_has_nothrow_assign<int>();
+    test_has_nothrow_assign<double>();
+    test_has_nothrow_assign<int*>();
+    test_has_nothrow_assign<const int*>();
+    test_has_nothrow_assign<NotEmpty>();
+    test_has_nothrow_assign<bit_zero>();
+
+    test_has_not_nothrow_assign<void>();
+    test_has_not_nothrow_assign<A>();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
index 62a59210074..8f5547ec22f 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_polymorphic.pass.cpp
@@ -52,8 +52,13 @@ class Abstract
     virtual ~Abstract() = 0;
 };
 
+#if __has_feature(cxx_attributes) 
 class Final final {
 };
+#else
+class Final {
+};
+#endif
 
 int main()
 {
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
index 70500f34d0d..668c4cdc7dd 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_standard_layout.pass.cpp
@@ -13,6 +13,24 @@
 
 #include <type_traits>
 
+template <class T>
+void test_is_standard_layout()
+{
+    static_assert( std::is_standard_layout<T>::value, "");
+    static_assert( std::is_standard_layout<const T>::value, "");
+    static_assert( std::is_standard_layout<volatile T>::value, "");
+    static_assert( std::is_standard_layout<const volatile T>::value, "");
+}
+
+template <class T>
+void test_is_not_standard_layout()
+{
+    static_assert(!std::is_standard_layout<T>::value, "");
+    static_assert(!std::is_standard_layout<const T>::value, "");
+    static_assert(!std::is_standard_layout<volatile T>::value, "");
+    static_assert(!std::is_standard_layout<const volatile T>::value, "");
+}
+
 template <class T1, class T2>
 struct pair
 {
@@ -22,9 +40,9 @@ struct pair
 
 int main()
 {
-    static_assert( std::is_standard_layout<int>::value, "");
-    static_assert( std::is_standard_layout<int[3]>::value, "");
-    static_assert(!std::is_standard_layout<int&>::value, "");
-    static_assert(!std::is_standard_layout<volatile int&>::value, "");
-    static_assert(( std::is_standard_layout<pair<int, double> >::value), "");
+    test_is_standard_layout<int> ();
+    test_is_standard_layout<int[3]> ();
+    test_is_standard_layout<pair<int, double> > ();
+
+    test_is_not_standard_layout<int&> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
index bf833c0a95a..af38699d881 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp
@@ -13,6 +13,24 @@
 
 #include <type_traits>
 
+template <class T>
+void test_is_trivial()
+{
+    static_assert( std::is_trivial<T>::value, "");
+    static_assert( std::is_trivial<const T>::value, "");
+    static_assert( std::is_trivial<volatile T>::value, "");
+    static_assert( std::is_trivial<const volatile T>::value, "");
+}
+
+template <class T>
+void test_is_not_trivial()
+{
+    static_assert(!std::is_trivial<T>::value, "");
+    static_assert(!std::is_trivial<const T>::value, "");
+    static_assert(!std::is_trivial<volatile T>::value, "");
+    static_assert(!std::is_trivial<const volatile T>::value, "");
+}
+
 struct A {};
 
 class B
@@ -23,9 +41,10 @@ public:
 
 int main()
 {
-    static_assert( std::is_trivial<int>::value, "");
-    static_assert(!std::is_trivial<int&>::value, "");
-    static_assert(!std::is_trivial<volatile int&>::value, "");
-    static_assert( std::is_trivial<A>::value, "");
-    static_assert(!std::is_trivial<B>::value, "");
+    test_is_trivial<int> ();
+    test_is_trivial<A> ();
+
+    test_is_not_trivial<int&> ();
+    test_is_not_trivial<volatile int&> ();
+    test_is_not_trivial<B> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivialially_copyable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivialially_copyable.pass.cpp
index 14f19ab3980..547c346cd61 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivialially_copyable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivialially_copyable.pass.cpp
@@ -14,6 +14,24 @@
 #include <type_traits>
 #include <cassert>
 
+template <class T>
+void test_is_trivially_copyable()
+{
+    static_assert( std::is_trivially_copyable<T>::value, "");
+    static_assert( std::is_trivially_copyable<const T>::value, "");
+    static_assert( std::is_trivially_copyable<volatile T>::value, "");
+    static_assert( std::is_trivially_copyable<const volatile T>::value, "");
+}
+
+template <class T>
+void test_is_not_trivially_copyable()
+{
+    static_assert(!std::is_trivially_copyable<T>::value, "");
+    static_assert(!std::is_trivially_copyable<const T>::value, "");
+    static_assert(!std::is_trivially_copyable<volatile T>::value, "");
+    static_assert(!std::is_trivially_copyable<const volatile T>::value, "");
+}
+
 struct A
 {
     int i_;
@@ -33,12 +51,13 @@ public:
 
 int main()
 {
-    static_assert( std::is_trivially_copyable<int>::value, "");
-    static_assert( std::is_trivially_copyable<const int>::value, "");
-    static_assert(!std::is_trivially_copyable<int&>::value, "");
-    static_assert( std::is_trivially_copyable<A>::value, "");
-    static_assert( std::is_trivially_copyable<const A>::value, "");
-    static_assert(!std::is_trivially_copyable<const A&>::value, "");
-    static_assert(!std::is_trivially_copyable<B>::value, "");
-    static_assert( std::is_trivially_copyable<C>::value, "");
+    test_is_trivially_copyable<int> ();
+    test_is_trivially_copyable<const int> ();
+    test_is_trivially_copyable<A> ();
+    test_is_trivially_copyable<const A> ();
+    test_is_trivially_copyable<C> ();
+
+    test_is_not_trivially_copyable<int&> ();
+    test_is_not_trivially_copyable<const A&> ();
+    test_is_not_trivially_copyable<B> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
index cd6d5d277be..984824a035d 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
@@ -13,6 +13,18 @@
 
 #include <type_traits>
 
+template <class T, class U>
+void test_is_trivially_assignable()
+{
+    static_assert(( std::is_trivially_assignable<T, U>::value), "");
+}
+
+template <class T, class U>
+void test_is_not_trivially_assignable()
+{
+    static_assert((!std::is_trivially_assignable<T, U>::value), "");
+}
+
 struct A
 {
 };
@@ -24,11 +36,12 @@ struct B
 
 int main()
 {
-    static_assert(( std::is_trivially_assignable<int&, int&>::value), "");
-    static_assert(( std::is_trivially_assignable<int&, int>::value), "");
-    static_assert((!std::is_trivially_assignable<int, int&>::value), "");
-    static_assert((!std::is_trivially_assignable<int, int>::value), "");
-    static_assert(( std::is_trivially_assignable<int&, double>::value), "");
-    static_assert((!std::is_trivially_assignable<B, A>::value), "");
-    static_assert((!std::is_trivially_assignable<A, B>::value), "");
+    test_is_trivially_assignable<int&, int&> ();
+    test_is_trivially_assignable<int&, int> ();
+    test_is_trivially_assignable<int&, double> ();
+
+    test_is_not_trivially_assignable<int, int&> ();
+    test_is_not_trivially_assignable<int, int> ();
+    test_is_not_trivially_assignable<B, A> ();
+    test_is_not_trivially_assignable<A, B> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
index ce0373baf28..4171d4d32f5 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
@@ -14,6 +14,36 @@
 
 #include <type_traits>
 
+template <class T>
+void test_is_trivially_constructible()
+{
+    static_assert(( std::is_trivially_constructible<T>::value), "");
+}
+
+template <class T, class A0>
+void test_is_trivially_constructible()
+{
+    static_assert(( std::is_trivially_constructible<T, A0>::value), "");
+}
+
+template <class T>
+void test_is_not_trivially_constructible()
+{
+    static_assert((!std::is_trivially_constructible<T>::value), "");
+}
+
+template <class T, class A0>
+void test_is_not_trivially_constructible()
+{
+    static_assert((!std::is_trivially_constructible<T, A0>::value), "");
+}
+
+template <class T, class A0, class A1>
+void test_is_not_trivially_constructible()
+{
+    static_assert((!std::is_trivially_constructible<T, A0, A1>::value), "");
+}
+
 struct A
 {
     explicit A(int);
@@ -22,9 +52,10 @@ struct A
 
 int main()
 {
-    static_assert(( std::is_trivially_constructible<int>::value), "");
-    static_assert(( std::is_trivially_constructible<int, const int&>::value), "");
-    static_assert((!std::is_trivially_constructible<A, int>::value), "");
-    static_assert((!std::is_trivially_constructible<A, int, double>::value), "");
-    static_assert((!std::is_trivially_constructible<A>::value), "");
+    test_is_trivially_constructible<int> ();
+    test_is_trivially_constructible<int, const int&> ();
+
+    test_is_not_trivially_constructible<A, int> ();
+    test_is_not_trivially_constructible<A, int, double> ();
+    test_is_not_trivially_constructible<A> ();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
index 2ec06a09e74..7d72565e40c 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
@@ -13,10 +13,16 @@
 
 #include <type_traits>
 
-template <class T, bool Result>
-void test_has_trivial_assign()
+template <class T>
+void test_has_trivially_copy_assignable()
 {
-    static_assert(std::is_trivially_copy_assignable<T>::value == Result, "");
+    static_assert( std::is_trivially_copy_assignable<T>::value, "");
+}
+
+template <class T>
+void test_has_not_trivially_copy_assignable()
+{
+    static_assert(!std::is_trivially_copy_assignable<T>::value, "");
 }
 
 class Empty
@@ -47,18 +53,19 @@ struct A
 
 int main()
 {
-    test_has_trivial_assign<void, false>();
-    test_has_trivial_assign<A, false>();
-    test_has_trivial_assign<int&, true>();
-    test_has_trivial_assign<NotEmpty, false>();
-    test_has_trivial_assign<Abstract, false>();
-    test_has_trivial_assign<const Empty, false>();
+    test_has_trivially_copy_assignable<int&>();
+    test_has_trivially_copy_assignable<Union>();
+    test_has_trivially_copy_assignable<Empty>();
+    test_has_trivially_copy_assignable<int>();
+    test_has_trivially_copy_assignable<double>();
+    test_has_trivially_copy_assignable<int*>();
+    test_has_trivially_copy_assignable<const int*>();
+    test_has_trivially_copy_assignable<bit_zero>();
+
+    test_has_not_trivially_copy_assignable<void>();
+    test_has_not_trivially_copy_assignable<A>();
+    test_has_not_trivially_copy_assignable<NotEmpty>();
+    test_has_not_trivially_copy_assignable<Abstract>();
+    test_has_not_trivially_copy_assignable<const Empty>();
 
-    test_has_trivial_assign<Union, true>();
-    test_has_trivial_assign<Empty, true>();
-    test_has_trivial_assign<int, true>();
-    test_has_trivial_assign<double, true>();
-    test_has_trivial_assign<int*, true>();
-    test_has_trivial_assign<const int*, true>();
-    test_has_trivial_assign<bit_zero, true>();
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
index dcdaa25b16a..c3fc7ac0a3d 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
@@ -13,10 +13,16 @@
 
 #include <type_traits>
 
-template <class T, bool Result>
+template <class T>
 void test_has_trivial_assign()
 {
-    static_assert(std::is_trivially_move_assignable<T>::value == Result, "");
+    static_assert( std::is_trivially_move_assignable<T>::value, "");
+}
+
+template <class T>
+void test_has_not_trivial_assign()
+{
+    static_assert(!std::is_trivially_move_assignable<T>::value, "");
 }
 
 class Empty
@@ -47,18 +53,19 @@ struct A
 
 int main()
 {
-    test_has_trivial_assign<void, false>();
-    test_has_trivial_assign<A, false>();
-    test_has_trivial_assign<int&, true>();
-    test_has_trivial_assign<NotEmpty, false>();
-    test_has_trivial_assign<Abstract, false>();
-    test_has_trivial_assign<const Empty, false>();
+    test_has_trivial_assign<int&>();
+    test_has_trivial_assign<Union>();
+    test_has_trivial_assign<Empty>();
+    test_has_trivial_assign<int>();
+    test_has_trivial_assign<double>();
+    test_has_trivial_assign<int*>();
+    test_has_trivial_assign<const int*>();
+    test_has_trivial_assign<bit_zero>();
+
+    test_has_not_trivial_assign<void>();
+    test_has_not_trivial_assign<A>();
+    test_has_not_trivial_assign<NotEmpty>();
+    test_has_not_trivial_assign<Abstract>();
+    test_has_not_trivial_assign<const Empty>();
 
-    test_has_trivial_assign<Union, true>();
-    test_has_trivial_assign<Empty, true>();
-    test_has_trivial_assign<int, true>();
-    test_has_trivial_assign<double, true>();
-    test_has_trivial_assign<int*, true>();
-    test_has_trivial_assign<const int*, true>();
-    test_has_trivial_assign<bit_zero, true>();
 }