diff --git a/libcxx/include/__config b/libcxx/include/__config
index f246066..4dde70ad 100644
--- a/libcxx/include/__config
+++ b/libcxx/include/__config
@@ -86,6 +86,8 @@
 
 #if defined(__clang__)
 
+#undef __STRICT_ANSI__
+
 #define _LIBCPP_HAS_NO_ADVANCED_SFINAE
 #define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 
diff --git a/libcxx/include/__split_buffer b/libcxx/include/__split_buffer
index e3c2b9d..88e2c83 100644
--- a/libcxx/include/__split_buffer
+++ b/libcxx/include/__split_buffer
@@ -118,12 +118,12 @@
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
 
     _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
-        {__destruct_at_begin(__new_begin, has_trivial_destructor<value_type>());}
+        {__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());}
         void __destruct_at_begin(pointer __new_begin, false_type);
         void __destruct_at_begin(pointer __new_begin, true_type);
 
     _LIBCPP_INLINE_VISIBILITY void __destruct_at_end(pointer __new_last)
-        {__destruct_at_end(__new_last, has_trivial_destructor<value_type>());}
+        {__destruct_at_end(__new_last, is_trivially_destructible<value_type>());}
         void __destruct_at_end(pointer __new_last, false_type);
         void __destruct_at_end(pointer __new_last, true_type);
 
@@ -230,8 +230,8 @@
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
-    __construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value &&
-                                                         has_trivial_copy_assign<value_type>::value>());
+    __construct_at_end(__n, __x, integral_constant<bool, is_trivially_copy_constructible<value_type>::value &&
+                                                         is_trivially_copy_assignable<value_type>::value>());
 }
 
 template <class _Tp, class _Allocator>
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index 17e20da..a3764df 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -1438,7 +1438,7 @@
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    has_trivial_copy_assign<_Tp>::value,
+    is_trivially_copy_assignable<_Tp>::value,
     _Tp*
 >::type
 __unwrap_iter(move_iterator<_Tp*> __i)
@@ -1450,7 +1450,7 @@
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    has_trivial_copy_assign<_Tp>::value,
+    is_trivially_copy_assignable<_Tp>::value,
     _Tp*
 >::type
 __unwrap_iter(__wrap_iter<_Tp*> __i)
@@ -1473,7 +1473,7 @@
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    has_trivial_copy_assign<_Up>::value,
+    is_trivially_copy_assignable<_Up>::value,
     _Up*
 >::type
 __copy(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1508,7 +1508,7 @@
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    has_trivial_copy_assign<_Up>::value,
+    is_trivially_copy_assignable<_Up>::value,
     _Up*
 >::type
 __copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1593,7 +1593,7 @@
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    has_trivial_copy_assign<_Up>::value,
+    is_trivially_copy_assignable<_Up>::value,
     _Up*
 >::type
 __move(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1628,7 +1628,7 @@
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    has_trivial_copy_assign<_Up>::value,
+    is_trivially_copy_assignable<_Up>::value,
     _Up*
 >::type
 __move_backward(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1766,7 +1766,7 @@
 {
    return _STD::__fill_n(__first, __n, __value, integral_constant<bool,
                                               is_pointer<_OutputIterator>::value &&
-                                              has_trivial_copy_assign<_Tp>::value     &&
+                                              is_trivially_copy_assignable<_Tp>::value     &&
                                               sizeof(_Tp) == 1>());
 }
 
@@ -2169,7 +2169,7 @@
                                    typename iterator_traits<_ForwardIterator>::iterator_category,
                                    random_access_iterator_tag
                                >::value &&
-                               has_trivial_copy_assign
+                               is_trivially_copy_assignable
                                <
                                    typename iterator_traits<_ForwardIterator>::value_type
                                >::value
@@ -3434,8 +3434,8 @@
     // _Compare is known to be a reference type
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
     typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-    const difference_type __limit = has_trivial_copy_constructor<value_type>::value &&
-                                    has_trivial_copy_assign<value_type>::value ? 30 : 6;
+    const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
+                                    is_trivially_copy_assignable<value_type>::value ? 30 : 6;
     while (true)
     {
     __restart:
@@ -4069,7 +4069,7 @@
 template <class _Tp>
 struct __inplace_merge_switch
 {
-    static const unsigned value = has_trivial_copy_assign<_Tp>::value;
+    static const unsigned value = is_trivially_copy_assignable<_Tp>::value;
 };
 
 template <class _BidirectionalIterator, class _Compare>
@@ -4237,7 +4237,7 @@
 template <class _Tp>
 struct __stable_sort_switch
 {
-    static const unsigned value = 128*has_trivial_copy_assign<_Tp>::value;
+    static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
 };
 
 template <class _Compare, class _RandomAccessIterator>
diff --git a/libcxx/include/iterator b/libcxx/include/iterator
index 0ad489b..6fcb259 100644
--- a/libcxx/include/iterator
+++ b/libcxx/include/iterator
@@ -1038,7 +1038,7 @@
 template <class _Tp>
 typename enable_if
 <
-    has_trivial_copy_assign<_Tp>::value,
+    is_trivially_copy_assignable<_Tp>::value,
     _Tp*
 >::type
 __unwrap_iter(__wrap_iter<_Tp*>);
@@ -1137,7 +1137,7 @@
     friend
     typename enable_if
     <
-        has_trivial_copy_assign<_Tp>::value,
+        is_trivially_copy_assignable<_Tp>::value,
         _Tp*
     >::type
     __unwrap_iter(__wrap_iter<_Tp*>);
diff --git a/libcxx/include/memory b/libcxx/include/memory
index ba00f52..c20e1a0 100644
--- a/libcxx/include/memory
+++ b/libcxx/include/memory
@@ -2446,15 +2446,15 @@
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void __incr(_Tp*)
-        {__incr(integral_constant<bool, has_trivial_destructor<_Tp>::value>());}
+        {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*)
-        {__set(__s, integral_constant<bool, has_trivial_destructor<_Tp>::value>());}
+        {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p)
-        {__process(__p, integral_constant<bool, has_trivial_destructor<_Tp>::value>());}
+        {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
 };
 
 template <class _Alloc>
diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits
index 7514330..6b8a99f 100644
--- a/libcxx/include/type_traits
+++ b/libcxx/include/type_traits
@@ -92,29 +92,32 @@
     template <class T> struct is_abstract;
 
     template <class T, class... Args> struct is_constructible;
+    template <class T>                struct is_default_constructible;
+    template <class T>                struct is_copy_constructible;
+    template <class T>                struct is_move_constructible;
+    template <class T, class U>       struct is_assignable;
+    template <class T>                struct is_copy_assignable;
+    template <class T>                struct is_move_assignable;
+    template <class T>                struct is_destructible;
+
+    template <class T, class... Args> struct is_trivially_constructible;
+    template <class T>                struct is_trivially_default_constructible;
+    template <class T>                struct is_trivially_copy_constructible;
+    template <class T>                struct is_trivially_move_constructible;
+    template <class T, class U>       struct is_trivially_assignable;
+    template <class T>                struct is_trivially_copy_assignable;
+    template <class T>                struct is_trivially_move_assignable;
+    template <class T>                struct is_trivially_destructible;
+
     template <class T, class... Args> struct is_nothrow_constructible;
+    template <class T>                struct is_nothrow_default_constructible;
+    template <class T>                struct is_nothrow_copy_constructible;
+    template <class T>                struct is_nothrow_move_constructible;
+    template <class T, class U>       struct is_nothrow_assignable;
+    template <class T>                struct is_nothrow_copy_assignable;
+    template <class T>                struct is_nothrow_move_assignable;
+    template <class T>                struct is_nothrow_destructible;
 
-    template <class T> struct has_trivial_default_constructor
-    template <class T> struct has_nothrow_default_constructor;
-    template <class T> struct has_default_constructor;
-
-    template <class T> struct has_trivial_copy_constructor;
-    template <class T> struct has_nothrow_copy_constructor;
-    template <class T> struct has_copy_constructor;
-
-    template <class T> struct has_trivial_move_constructor;
-    template <class T> struct has_nothrow_move_constructor;
-    template <class T> struct has_move_constructor;
-
-    template <class T> struct has_trivial_copy_assign;
-    template <class T> struct has_nothrow_copy_assign;
-    template <class T> struct has_copy_assign;
-
-    template <class T> struct has_trivial_move_assign;
-    template <class T> struct has_nothrow_move_assign;
-    template <class T> struct has_move_assign;
-
-    template <class T> struct has_trivial_destructor;
     template <class T> struct has_virtual_destructor;
 
     // Relationships between types:
@@ -777,118 +780,6 @@
 template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic
     : public __libcpp_polymorphic<_Tp> {};
 
-// has_trivial_default_constructor
-
-#ifdef _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_default_constructor
-    : public integral_constant<bool, __has_trivial_constructor(_Tp)> {};
-
-#else  // _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct __has_trivial_default_constructor
-    : public integral_constant<bool, is_scalar<_Tp>::value> {};
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_default_constructor
-    : public __has_trivial_default_constructor<typename remove_all_extents<_Tp>::type> {};
-
-#endif  // _LIBCPP_HAS_TYPE_TRAITS
-
-// has_nothrow_default_constructor
-
-#ifdef _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_default_constructor
-    : public integral_constant<bool, __has_nothrow_constructor(_Tp)> {};
-
-#else  // _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_default_constructor
-    : public has_trivial_default_constructor<_Tp> {};
-
-#endif  // _LIBCPP_HAS_TYPE_TRAITS
-
-// has_trivial_copy_constructor
-
-#ifdef _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_constructor
-    : public integral_constant<bool, __has_trivial_copy(_Tp)> {};
-
-#else  // _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_constructor
-    : public integral_constant<bool, is_scalar<_Tp>::value ||
-                                     is_reference<_Tp>::value> {};
-
-#endif  // _LIBCPP_HAS_TYPE_TRAITS
-
-// has_nothrow_copy_constructor
-
-#ifdef _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_constructor
-    : public integral_constant<bool, __has_nothrow_copy(_Tp)> {};
-
-#else  // _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_constructor
-    : public has_trivial_copy_constructor<_Tp> {};
-
-#endif  // _LIBCPP_HAS_TYPE_TRAITS
-
-// has_nothrow_move_constructor
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_move_constructor
-    : public has_nothrow_copy_constructor<_Tp> {};
-
-// has_trivial_copy_assign
-
-#ifdef _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_assign
-    : public integral_constant<bool, __has_trivial_assign(_Tp)> {};
-
-#else  // _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_assign
-    : public integral_constant<bool, is_scalar<_Tp>::value &&
-                                    !is_const<_Tp>::value> {};
-
-#endif  // _LIBCPP_HAS_TYPE_TRAITS
-
-// has_nothrow_copy_assign
-
-#ifdef _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_assign
-    : public integral_constant<bool, __has_nothrow_assign(_Tp)> {};
-
-#else  // _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_assign
-    : public has_trivial_copy_assign<_Tp> {};
-
-#endif  // _LIBCPP_HAS_TYPE_TRAITS
-
-// has_trivial_destructor
-
-#ifdef _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_destructor
-    : public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
-
-#else  // _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct __libcpp_trivial_destructor
-    : public integral_constant<bool, is_scalar<_Tp>::value ||
-                                     is_reference<_Tp>::value> {};
-
-template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_destructor
-    : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
-
-#endif  // _LIBCPP_HAS_TYPE_TRAITS
-
 // has_virtual_destructor
 
 #ifdef _LIBCPP_HAS_TYPE_TRAITS
@@ -903,23 +794,6 @@
 
 #endif  // _LIBCPP_HAS_TYPE_TRAITS
 
-// is_pod
-
-#ifdef _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE is_pod
-    : public integral_constant<bool, __is_pod(_Tp)> {};
-
-#else  // _LIBCPP_HAS_TYPE_TRAITS
-
-template <class _Tp> struct _LIBCPP_VISIBLE is_pod
-    : public integral_constant<bool, has_trivial_default_constructor<_Tp>::value   &&
-                                     has_trivial_copy_constructor<_Tp>::value      &&
-                                     has_trivial_copy_assign<_Tp>::value    &&
-                                     has_trivial_destructor<_Tp>::value> {};
-
-#endif  // _LIBCPP_HAS_TYPE_TRAITS
-
 // alignment_of
 
 template <class _Tp> struct __alignment_of {_Tp _;};
@@ -1287,6 +1161,8 @@
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
+// is_assignable
+
 template <class _Tp, class _Arg>
 decltype((_STD::declval<_Tp>() = _STD::declval<_Arg>(), true_type()))
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1311,19 +1187,56 @@
         >::type {};
 
 template <class _Tp, class _Arg>
-struct __is_assignable
+struct is_assignable
     : public __is_assignable_imp<_Tp, _Arg> {};
 
-// has_copy_assign
+// is_copy_assignable
 
-template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign
-    : public __is_assignable<_Tp&, const _Tp&> {};
+template <class _Tp> struct _LIBCPP_VISIBLE is_copy_assignable
+    : public is_assignable<_Tp&, const _Tp&> {};
 
-template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign<_Tp[]>
+// is_move_assignable
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_move_assignable
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    : public is_assignable<_Tp&, _Tp&&> {};
+#else
+    : public is_copy_assignable<_Tp> {};
+#endif
+
+// is_destructible
+
+template <class _Tp>
+struct __destructible_test
+{
+    _Tp __t;
+};
+
+template <class _Tp>
+decltype((_STD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+__is_destructible_test(_Tp&&);
+#else
+__is_destructible_test(_Tp&);
+#endif
+
+false_type
+__is_destructible_test(__any);
+
+template <class _Tp, bool = is_void<_Tp>::value || is_abstract<_Tp>::value>
+struct __destructible_imp
+    : public common_type
+        <
+            decltype(__is_destructible_test(declval<_Tp>()))
+        >::type {};
+
+template <class _Tp>
+struct __destructible_imp<_Tp, true>
     : public false_type {};
 
-template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign<_Tp&>
-    : public false_type {};
+template <class _Tp>
+struct is_destructible
+    : public __destructible_imp<_Tp> {};
 
 // move
 
@@ -1638,7 +1551,7 @@
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#ifndef _LIBCPP_HAS_NO_VARIADICS
 
 // template <class T, class... Args> struct is_constructible;
 
@@ -1758,24 +1671,35 @@
     : public false_type
     {};
 
-template <class _Tp>
-struct _LIBCPP_VISIBLE has_default_constructor
-    : public is_constructible<_Tp>
-    {};
-
-#else  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#else  // _LIBCPP_HAS_NO_VARIADICS
 
 // template <class T> struct is_constructible0;
 
 //      main is_constructible0 test
 
 template <class _Tp>
-decltype((_STD::move(_Tp()), true_type()))
+decltype((_Tp(), true_type()))
 __is_constructible0_test(_Tp&);
 
 false_type
 __is_constructible0_test(__any);
 
+template <class _Tp, class _A0>
+decltype((_Tp(_STD::declval<_A0>()), true_type()))
+__is_constructible1_test(_Tp&, _A0&);
+
+template <class _A0>
+false_type
+__is_constructible1_test(__any, _A0&);
+
+template <class _Tp, class _A0, class _A1>
+decltype((_Tp(_STD::declval<_A0>(), _STD::declval<_A1>()), true_type()))
+__is_constructible2_test(_Tp&, _A0&, _A1&);
+
+template <class _A0, class _A1>
+false_type
+__is_constructible2_test(__any, _A0&, _A1&);
+
 template <bool, class _Tp>
 struct __is_constructible0_imp // false, _Tp is not a scalar
     : public common_type
@@ -1784,6 +1708,22 @@
              >::type
     {};
 
+template <bool, class _Tp, class _A0>
+struct __is_constructible1_imp // false, _Tp is not a scalar
+    : public common_type
+             <
+                 decltype(__is_constructible1_test(declval<_Tp&>(), declval<_A0&>()))
+             >::type
+    {};
+
+template <bool, class _Tp, class _A0, class _A1>
+struct __is_constructible2_imp // false, _Tp is not a scalar
+    : public common_type
+             <
+                 decltype(__is_constructible2_test(declval<_Tp&>(), declval<_A0>(), declval<_A1>()))
+             >::type
+    {};
+
 //      handle scalars and reference types
 
 //      Scalars are default constructible, references are not
@@ -1793,6 +1733,16 @@
     : public is_scalar<_Tp>
     {};
 
+template <class _Tp, class _A0>
+struct __is_constructible1_imp<true, _Tp, _A0>
+    : public is_convertible<_A0, _Tp>
+    {};
+
+template <class _Tp, class _A0, class _A1>
+struct __is_constructible2_imp<true, _Tp, _A0, _A1>
+    : public false_type
+    {};
+
 //      Treat scalars and reference types separately
 
 template <bool, class _Tp>
@@ -1801,6 +1751,18 @@
                                 _Tp>
     {};
 
+template <bool, class _Tp, class _A0>
+struct __is_constructible1_void_check
+    : public __is_constructible1_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value,
+                                _Tp, _A0>
+    {};
+
+template <bool, class _Tp, class _A0, class _A1>
+struct __is_constructible2_void_check
+    : public __is_constructible2_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value,
+                                _Tp, _A0, _A1>
+    {};
+
 //      If any of T or Args is void, is_constructible should be false
 
 template <class _Tp>
@@ -1808,21 +1770,69 @@
     : public false_type
     {};
 
-//      has_default_constructor entry point
+template <class _Tp, class _A0>
+struct __is_constructible1_void_check<true, _Tp, _A0>
+    : public false_type
+    {};
+
+template <class _Tp, class _A0, class _A1>
+struct __is_constructible2_void_check<true, _Tp, _A0, _A1>
+    : public false_type
+    {};
+
+//      is_constructible entry point
+
+namespace __is_construct
+{
+
+struct __nat {};
+
+}
+
+template <class _Tp, class _A0 = __is_construct::__nat,
+                     class _A1 = __is_construct::__nat>
+struct _LIBCPP_VISIBLE is_constructible
+    : public __is_constructible2_void_check<is_void<_Tp>::value
+                                        || is_abstract<_Tp>::value
+                                        || is_function<_Tp>::value
+                                        || is_void<_A0>::value
+                                        || is_void<_A1>::value,
+                                           _Tp, _A0, _A1>
+    {};
 
 template <class _Tp>
-struct _LIBCPP_VISIBLE has_default_constructor
+struct _LIBCPP_VISIBLE is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat>
     : public __is_constructible0_void_check<is_void<_Tp>::value
-                                        || is_abstract<_Tp>::value,
+                                        || is_abstract<_Tp>::value
+                                        || is_function<_Tp>::value,
                                            _Tp>
     {};
 
+template <class _Tp, class _A0>
+struct _LIBCPP_VISIBLE is_constructible<_Tp, _A0, __is_construct::__nat>
+    : public __is_constructible1_void_check<is_void<_Tp>::value
+                                        || is_abstract<_Tp>::value
+                                        || is_function<_Tp>::value
+                                        || is_void<_A0>::value,
+                                           _Tp, _A0>
+    {};
+
 //      Array types are default constructible if their element type
 //      is default constructible
 
 template <class _A, size_t _N>
 struct __is_constructible0_imp<false, _A[_N]>
-    : public has_default_constructor<typename remove_all_extents<_A>::type>
+    : public is_constructible<typename remove_all_extents<_A>::type>
+    {};
+
+template <class _A, size_t _N, class _A0>
+struct __is_constructible1_imp<false, _A[_N], _A0>
+    : public false_type
+    {};
+
+template <class _A, size_t _N, class _A0, class _A1>
+struct __is_constructible2_imp<false, _A[_N], _A0, _A1>
+    : public false_type
     {};
 
 //      Incomplete array types are not constructible
@@ -1832,25 +1842,468 @@
     : public false_type
     {};
 
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-
-// has_copy_constructor
-
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
-
-template <class _Tp>
-struct _LIBCPP_VISIBLE has_copy_constructor
-    : public is_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type>
+template <class _A, class _A0>
+struct __is_constructible1_imp<false, _A[], _A0>
+    : public false_type
     {};
 
-#else  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-
-template <class _Tp>
-struct _LIBCPP_VISIBLE has_copy_constructor
-    : public has_nothrow_copy_constructor<_Tp>
+template <class _A, class _A0, class _A1>
+struct __is_constructible2_imp<false, _A[], _A0, _A1>
+    : public false_type
     {};
 
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
+#endif  // _LIBCPP_HAS_NO_VARIADICS
+
+// is_default_constructible
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_default_constructible
+    : public is_constructible<_Tp>
+    {};
+
+// is_copy_constructible
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_copy_constructible
+    : public is_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
+    {};
+
+// is_move_constructible
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_move_constructible
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
+#else
+    : public is_copy_constructible<_Tp>
+#endif
+    {};
+
+// is_trivially_constructible
+
+#ifndef _LIBCPP_HAS_NO_VARIADICS
+
+template <class _Tp, class... _Args>
+struct _LIBCPP_VISIBLE is_trivially_constructible
+    : false_type
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_constructor(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&&>
+#else
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp>
+#endif
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+#else  // _LIBCPP_HAS_NO_VARIADICS
+
+template <class _Tp, class _A0 = __is_construct::__nat,
+                     class _A1 = __is_construct::__nat>
+struct _LIBCPP_VISIBLE is_trivially_constructible
+    : false_type
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, __is_construct::__nat,
+                                                       __is_construct::__nat>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_constructor(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp,
+                                                       __is_construct::__nat>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&,
+                                                       __is_construct::__nat>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&,
+                                                       __is_construct::__nat>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+#endif  // _LIBCPP_HAS_NO_VARIADICS
+
+// is_trivially_default_constructible
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_default_constructible
+    : public is_trivially_constructible<_Tp>
+    {};
+
+// is_trivially_copy_constructible
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copy_constructible
+    : public is_trivially_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
+    {};
+
+// is_trivially_move_constructible
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_constructible
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
+#else
+    : public is_trivially_copy_constructible<_Tp>
+#endif
+    {};
+
+// is_trivially_assignable
+
+template <class _Tp, class _Arg>
+struct is_trivially_assignable
+    : public false_type {};
+
+template <class _Tp>
+struct is_trivially_assignable<_Tp&, _Tp>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_assign(_Tp)> {};
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value> {};
+#endif
+
+template <class _Tp>
+struct is_trivially_assignable<_Tp&, _Tp&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_assign(_Tp)> {};
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value> {};
+#endif
+
+template <class _Tp>
+struct is_trivially_assignable<_Tp&, const _Tp&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_assign(_Tp)> {};
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value> {};
+#endif
+
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+template <class _Tp>
+struct is_trivially_assignable<_Tp&, _Tp&&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_trivial_assign(_Tp)> {};
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value> {};
+#endif
+
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+// is_trivially_copy_assignable
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copy_assignable
+    : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
+                               const typename add_lvalue_reference<_Tp>::type>
+    {};
+
+// is_trivially_move_assignable
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_assignable
+    : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+                                     typename add_rvalue_reference<_Tp>::type>
+#else
+                                     typename add_lvalue_reference<_Tp>::type>
+#endif
+    {};
+
+// is_trivially_destructible
+
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_destructible
+    : public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
+
+#else  // _LIBCPP_HAS_TYPE_TRAITS
+
+template <class _Tp> struct __libcpp_trivial_destructor
+    : public integral_constant<bool, is_scalar<_Tp>::value ||
+                                     is_reference<_Tp>::value> {};
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_destructible
+    : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
+
+#endif  // _LIBCPP_HAS_TYPE_TRAITS
+
+// is_nothrow_constructible
+
+#ifndef _LIBCPP_HAS_NO_VARIADICS
+
+template <class _Tp, class... _Args>
+struct _LIBCPP_VISIBLE is_nothrow_constructible
+    : false_type
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_constructor(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&&>
+#else
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp>
+#endif
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+#else  // _LIBCPP_HAS_NO_VARIADICS
+
+template <class _Tp, class _A0 = __is_construct::__nat,
+                     class _A1 = __is_construct::__nat>
+struct _LIBCPP_VISIBLE is_nothrow_constructible
+    : false_type
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, __is_construct::__nat,
+                                                       __is_construct::__nat>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_constructor(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp,
+                                                       __is_construct::__nat>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&,
+                                                       __is_construct::__nat>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+template <class _Tp>
+struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&,
+                                                       __is_construct::__nat>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_copy(_Tp)>
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value>
+#endif
+{
+};
+
+#endif  // _LIBCPP_HAS_NO_VARIADICS
+
+// is_nothrow_default_constructible
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_default_constructible
+    : public is_nothrow_constructible<_Tp>
+    {};
+
+// is_nothrow_copy_constructible
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_copy_constructible
+    : public is_nothrow_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
+    {};
+
+// is_nothrow_move_constructible
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_move_constructible
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
+#else
+    : public is_nothrow_copy_constructible<_Tp>
+#endif
+    {};
+
+// is_nothrow_assignable
+
+template <class _Tp, class _Arg>
+struct is_nothrow_assignable
+    : public false_type {};
+
+template <class _Tp>
+struct is_nothrow_assignable<_Tp&, _Tp>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value> {};
+#endif
+
+template <class _Tp>
+struct is_nothrow_assignable<_Tp&, _Tp&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value> {};
+#endif
+
+template <class _Tp>
+struct is_nothrow_assignable<_Tp&, const _Tp&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value> {};
+#endif
+
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+template <class _Tp>
+struct is_nothrow_assignable<_Tp&, _Tp&&>
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+    : integral_constant<bool, __has_nothrow_assign(_Tp)> {};
+#else
+    : integral_constant<bool, is_scalar<_Tp>::value> {};
+#endif
+
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+// is_nothrow_copy_assignable
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_copy_assignable
+    : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
+                               const typename add_lvalue_reference<_Tp>::type>
+    {};
+
+// is_nothrow_move_assignable
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_move_assignable
+    : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+                                     typename add_rvalue_reference<_Tp>::type>
+#else
+                                     typename add_lvalue_reference<_Tp>::type>
+#endif
+    {};
+
+// is_nothrow_destructible
+
+template <class _Tp> struct __libcpp_nothrow_destructor
+    : public integral_constant<bool, is_scalar<_Tp>::value ||
+                                     is_reference<_Tp>::value> {};
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_destructible
+    : public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {};
+
+// is_pod
+
+#ifdef _LIBCPP_HAS_TYPE_TRAITS
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_pod
+    : public integral_constant<bool, __is_pod(_Tp)> {};
+
+#else  // _LIBCPP_HAS_TYPE_TRAITS
+
+template <class _Tp> struct _LIBCPP_VISIBLE is_pod
+    : public integral_constant<bool, is_trivially_default_constructible<_Tp>::value   &&
+                                     is_trivially_copy_constructible<_Tp>::value      &&
+                                     is_trivially_copy_assignable<_Tp>::value    &&
+                                     is_trivially_destructible<_Tp>::value> {};
+
+#endif  // _LIBCPP_HAS_TYPE_TRAITS
 
 template <class _Tp> struct __is_zero_default_constructible
     : public integral_constant<bool, is_scalar<_Tp>::value || is_empty<_Tp>::value> {};
diff --git a/libcxx/include/utility b/libcxx/include/utility
index f4c94be..f8a8fc5 100644
--- a/libcxx/include/utility
+++ b/libcxx/include/utility
@@ -38,7 +38,7 @@
 template <class T>
     typename conditional
     <
-        !has_nothrow_move_constructor<T>::value && has_copy_constructor<T>::value,
+        !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
         const T&,
         T&&
     >::type
@@ -178,7 +178,7 @@
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 typename conditional
 <
-    !has_nothrow_move_constructor<_Tp>::value && has_copy_constructor<_Tp>::value,
+    !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
     const _Tp&,
     _Tp&&
 >::type
diff --git a/libcxx/include/vector b/libcxx/include/vector
index 80b1cef..074e445 100644
--- a/libcxx/include/vector
+++ b/libcxx/include/vector
@@ -326,7 +326,7 @@
     _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __begin_);}
 
     _LIBCPP_INLINE_VISIBILITY void __destruct_at_end(const_pointer __new_last)
-        {__destruct_at_end(__new_last, has_trivial_destructor<value_type>());}
+        {__destruct_at_end(__new_last, is_trivially_destructible<value_type>());}
         void __destruct_at_end(const_pointer __new_last, false_type);
         void __destruct_at_end(const_pointer __new_last, true_type);
 
@@ -771,8 +771,8 @@
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
-    __construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value &&
-                                                         has_trivial_copy_assign<value_type>::value>());
+    __construct_at_end(__n, __x, integral_constant<bool, is_trivially_copy_constructible<value_type>::value &&
+                                                         is_trivially_copy_assignable<value_type>::value>());
 }
 
 template <class _Tp, class _Allocator>
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_assign.pass.cpp
deleted file mode 100644
index c650372..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_assign.pass.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_copy_assign
-
-#include <type_traits>
-
-class Empty
-{
-};
-
-class NotEmpty
-{
-public:
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-struct A
-{
-    A();
-};
-
-int main()
-{
-    static_assert(( std::has_copy_assign<int>::value), "");
-    static_assert((!std::has_copy_assign<const int>::value), "");
-    static_assert((!std::has_copy_assign<int[]>::value), "");
-    static_assert((!std::has_copy_assign<int[3]>::value), "");
-    static_assert((!std::has_copy_assign<int&>::value), "");
-    static_assert(( std::has_copy_assign<A>::value), "");
-    static_assert(( std::has_copy_assign<bit_zero>::value), "");
-    static_assert(( std::has_copy_assign<Union>::value), "");
-    static_assert(( std::has_copy_assign<NotEmpty>::value), "");
-    static_assert(( std::has_copy_assign<Empty>::value), "");
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_constructor.pass.cpp
deleted file mode 100644
index 8d74613..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_constructor.pass.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_copy_constructor
-
-#include <type_traits>
-
-template <class T, bool Result>
-void test_has_copy_constructor()
-{
-    static_assert(std::has_copy_constructor<T>::value == Result, "");
-}
-
-class Empty
-{
-};
-
-class NotEmpty
-{
-public:
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-class Abstract
-{
-public:
-    virtual ~Abstract() = 0;
-};
-
-struct A
-{
-    A(const A&);
-};
-
-int main()
-{
-    test_has_copy_constructor<char[3], false>();
-    test_has_copy_constructor<char[], false>();
-    test_has_copy_constructor<void, false>();
-    test_has_copy_constructor<Abstract, false>();
-
-    test_has_copy_constructor<A, true>();
-    test_has_copy_constructor<int&, true>();
-    test_has_copy_constructor<Union, true>();
-    test_has_copy_constructor<Empty, true>();
-    test_has_copy_constructor<int, true>();
-    test_has_copy_constructor<double, true>();
-    test_has_copy_constructor<int*, true>();
-    test_has_copy_constructor<const int*, true>();
-    test_has_copy_constructor<NotEmpty, true>();
-    test_has_copy_constructor<bit_zero, true>();
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_default_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_default_constructor.pass.cpp
deleted file mode 100644
index 7a4c98b..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_default_constructor.pass.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_default_constructor
-
-#include <type_traits>
-
-template <class T, bool Result>
-void test_has_default_constructor()
-{
-    static_assert(std::has_default_constructor<T>::value == Result, "");
-    static_assert(std::has_default_constructor<const T>::value == Result, "");
-    static_assert(std::has_default_constructor<volatile T>::value == Result, "");
-    static_assert(std::has_default_constructor<const volatile T>::value == Result, "");
-}
-
-class Empty
-{
-};
-
-class NotEmpty
-{
-public:
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-class Abstract
-{
-public:
-    virtual ~Abstract() = 0;
-};
-
-struct A
-{
-    A();
-};
-
-int main()
-{
-    test_has_default_constructor<void, false>();
-    test_has_default_constructor<int&, false>();
-    test_has_default_constructor<char[], false>();
-    test_has_default_constructor<Abstract, false>();
-
-    test_has_default_constructor<A, true>();
-    test_has_default_constructor<Union, true>();
-    test_has_default_constructor<Empty, true>();
-    test_has_default_constructor<int, true>();
-    test_has_default_constructor<double, true>();
-    test_has_default_constructor<int*, true>();
-    test_has_default_constructor<const int*, true>();
-    test_has_default_constructor<char[3], true>();
-    test_has_default_constructor<NotEmpty, true>();
-    test_has_default_constructor<bit_zero, true>();
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_assign.pass.cpp
deleted file mode 100644
index 135a0ed..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_assign.pass.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_move_assign
-
-#include <type_traits>
-
-int main()
-{
-#error has_move_assign not implemented
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_constructor.pass.cpp
deleted file mode 100644
index 0f1161e..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_constructor.pass.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_move_constructor
-
-#include <type_traits>
-
-int main()
-{
-#error has_move_constructor not implemented
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_constructor.pass.cpp
deleted file mode 100644
index 5360087..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_constructor.pass.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_nothrow_copy_constructor
-
-#include <type_traits>
-
-template <class T>
-void test_has_nothrow_copy_constructor()
-{
-    static_assert( std::has_nothrow_copy_constructor<T>::value, "");
-    static_assert( std::has_nothrow_copy_constructor<const T>::value, "");
-    static_assert( std::has_nothrow_copy_constructor<volatile T>::value, "");
-    static_assert( std::has_nothrow_copy_constructor<const volatile T>::value, "");
-}
-
-template <class T>
-void test_has_not_nothrow_copy_constructor()
-{
-    static_assert(!std::has_nothrow_copy_constructor<T>::value, "");
-    static_assert(!std::has_nothrow_copy_constructor<const T>::value, "");
-    static_assert(!std::has_nothrow_copy_constructor<volatile T>::value, "");
-    static_assert(!std::has_nothrow_copy_constructor<const volatile T>::value, "");
-}
-
-class Empty
-{
-};
-
-class NotEmpty
-{
-public:
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-class Abstract
-{
-public:
-    virtual ~Abstract() = 0;
-};
-
-struct A
-{
-    A(const A&);
-};
-
-int main()
-{
-    test_has_not_nothrow_copy_constructor<void>();
-    test_has_not_nothrow_copy_constructor<A>();
-    test_has_not_nothrow_copy_constructor<Abstract>();
-    test_has_not_nothrow_copy_constructor<char[3]>();
-    test_has_not_nothrow_copy_constructor<char[]>();
-
-    test_has_nothrow_copy_constructor<int&>();
-    test_has_nothrow_copy_constructor<Union>();
-    test_has_nothrow_copy_constructor<Empty>();
-    test_has_nothrow_copy_constructor<int>();
-    test_has_nothrow_copy_constructor<double>();
-    test_has_nothrow_copy_constructor<int*>();
-    test_has_nothrow_copy_constructor<const int*>();
-    test_has_nothrow_copy_constructor<NotEmpty>();
-    test_has_nothrow_copy_constructor<bit_zero>();
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_default_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_default_constructor.pass.cpp
deleted file mode 100644
index 0715783..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_default_constructor.pass.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_nothrow_default_constructor
-
-#include <type_traits>
-
-template <class T>
-void test_has_nothrow_default_constructor()
-{
-    static_assert( std::has_nothrow_default_constructor<T>::value, "");
-    static_assert( std::has_nothrow_default_constructor<const T>::value, "");
-    static_assert( std::has_nothrow_default_constructor<volatile T>::value, "");
-    static_assert( std::has_nothrow_default_constructor<const volatile T>::value, "");
-}
-
-template <class T>
-void test_has_not_nothrow_default_constructor()
-{
-    static_assert(!std::has_nothrow_default_constructor<T>::value, "");
-    static_assert(!std::has_nothrow_default_constructor<const T>::value, "");
-    static_assert(!std::has_nothrow_default_constructor<volatile T>::value, "");
-    static_assert(!std::has_nothrow_default_constructor<const volatile T>::value, "");
-}
-
-class Empty
-{
-};
-
-class NotEmpty
-{
-public:
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-class Abstract
-{
-public:
-    virtual ~Abstract() = 0;
-};
-
-struct A
-{
-    A();
-};
-
-int main()
-{
-    test_has_not_nothrow_default_constructor<void>();
-    test_has_not_nothrow_default_constructor<int&>();
-    test_has_not_nothrow_default_constructor<A>();
-    test_has_not_nothrow_default_constructor<char[]>();
-    test_has_not_nothrow_default_constructor<Abstract>();
-
-    test_has_nothrow_default_constructor<Union>();
-    test_has_nothrow_default_constructor<Empty>();
-    test_has_nothrow_default_constructor<int>();
-    test_has_nothrow_default_constructor<double>();
-    test_has_nothrow_default_constructor<int*>();
-    test_has_nothrow_default_constructor<const int*>();
-    test_has_nothrow_default_constructor<char[3]>();
-    test_has_nothrow_default_constructor<NotEmpty>();
-    test_has_nothrow_default_constructor<bit_zero>();
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_assign.pass.cpp
deleted file mode 100644
index bee6a06..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_assign.pass.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_nothrow_move_assign
-
-#include <type_traits>
-
-int main()
-{
-#error has_nothrow_move_assign not implemented
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_constructor.pass.cpp
deleted file mode 100644
index 949256a..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_constructor.pass.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_nothrow_move_constructor
-
-#include <type_traits>
-
-int main()
-{
-#error has_nothrow_move_constructor not implemented
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_constructor.pass.cpp
deleted file mode 100644
index 6844661..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_constructor.pass.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_trivial_copy_constructor
-
-#include <type_traits>
-
-template <class T>
-void test_has_trivial_copy_constructor()
-{
-    static_assert( std::has_trivial_copy_constructor<T>::value, "");
-    static_assert( std::has_trivial_copy_constructor<const T>::value, "");
-    static_assert( std::has_trivial_copy_constructor<volatile T>::value, "");
-    static_assert( std::has_trivial_copy_constructor<const volatile T>::value, "");
-}
-
-template <class T>
-void test_has_not_trivial_copy_constructor()
-{
-    static_assert(!std::has_trivial_copy_constructor<T>::value, "");
-    static_assert(!std::has_trivial_copy_constructor<const T>::value, "");
-    static_assert(!std::has_trivial_copy_constructor<volatile T>::value, "");
-    static_assert(!std::has_trivial_copy_constructor<const volatile T>::value, "");
-}
-
-class Empty
-{
-};
-
-class NotEmpty
-{
-public:
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-class Abstract
-{
-public:
-    virtual ~Abstract() = 0;
-};
-
-struct A
-{
-    A(const A&);
-};
-
-int main()
-{
-    test_has_not_trivial_copy_constructor<void>();
-    test_has_not_trivial_copy_constructor<A>();
-    test_has_not_trivial_copy_constructor<char[3]>();
-    test_has_not_trivial_copy_constructor<char[]>();
-    test_has_not_trivial_copy_constructor<Abstract>();
-    test_has_not_trivial_copy_constructor<NotEmpty>();
-
-    test_has_trivial_copy_constructor<int&>();
-    test_has_trivial_copy_constructor<Union>();
-    test_has_trivial_copy_constructor<Empty>();
-    test_has_trivial_copy_constructor<int>();
-    test_has_trivial_copy_constructor<double>();
-    test_has_trivial_copy_constructor<int*>();
-    test_has_trivial_copy_constructor<const int*>();
-    test_has_trivial_copy_constructor<bit_zero>();
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_default_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_default_constructor.pass.cpp
deleted file mode 100644
index 7dda08e..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_default_constructor.pass.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_trivial_default_constructor
-
-#include <type_traits>
-
-template <class T>
-void test_has_trivial_default_constructor()
-{
-    static_assert( std::has_trivial_default_constructor<T>::value, "");
-    static_assert( std::has_trivial_default_constructor<const T>::value, "");
-    static_assert( std::has_trivial_default_constructor<volatile T>::value, "");
-    static_assert( std::has_trivial_default_constructor<const volatile T>::value, "");
-}
-
-template <class T>
-void test_has_not_trivial_default_constructor()
-{
-    static_assert(!std::has_trivial_default_constructor<T>::value, "");
-    static_assert(!std::has_trivial_default_constructor<const T>::value, "");
-    static_assert(!std::has_trivial_default_constructor<volatile T>::value, "");
-    static_assert(!std::has_trivial_default_constructor<const volatile T>::value, "");
-}
-
-class Empty
-{
-};
-
-class NotEmpty
-{
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-class Abstract
-{
-    virtual ~Abstract() = 0;
-};
-
-struct A
-{
-    A();
-};
-
-int main()
-{
-    test_has_not_trivial_default_constructor<void>();
-    test_has_not_trivial_default_constructor<int&>();
-    test_has_not_trivial_default_constructor<A>();
-    test_has_not_trivial_default_constructor<Abstract>();
-    test_has_not_trivial_default_constructor<NotEmpty>();
-    test_has_not_trivial_default_constructor<char[]>();
-
-    test_has_trivial_default_constructor<Union>();
-    test_has_trivial_default_constructor<Empty>();
-    test_has_trivial_default_constructor<int>();
-    test_has_trivial_default_constructor<double>();
-    test_has_trivial_default_constructor<int*>();
-    test_has_trivial_default_constructor<const int*>();
-    test_has_trivial_default_constructor<char[3]>();
-    test_has_trivial_default_constructor<bit_zero>();
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_destructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_destructor.pass.cpp
deleted file mode 100644
index cbfc416..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_destructor.pass.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_trivial_destructor
-
-#include <type_traits>
-
-template <class T>
-void test_has_trivial_destructor()
-{
-    static_assert( std::has_trivial_destructor<T>::value, "");
-    static_assert( std::has_trivial_destructor<const T>::value, "");
-    static_assert( std::has_trivial_destructor<volatile T>::value, "");
-    static_assert( std::has_trivial_destructor<const volatile T>::value, "");
-}
-
-template <class T>
-void test_has_not_trivial_destructor()
-{
-    static_assert(!std::has_trivial_destructor<T>::value, "");
-    static_assert(!std::has_trivial_destructor<const T>::value, "");
-    static_assert(!std::has_trivial_destructor<volatile T>::value, "");
-    static_assert(!std::has_trivial_destructor<const volatile T>::value, "");
-}
-
-class Empty
-{
-};
-
-class NotEmpty
-{
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-class Abstract
-{
-    virtual ~Abstract() = 0;
-};
-
-struct A
-{
-    ~A();
-};
-
-int main()
-{
-    test_has_not_trivial_destructor<void>();
-    test_has_not_trivial_destructor<A>();
-    test_has_not_trivial_destructor<Abstract>();
-    test_has_not_trivial_destructor<NotEmpty>();
-
-    test_has_trivial_destructor<int&>();
-    test_has_trivial_destructor<Union>();
-    test_has_trivial_destructor<Empty>();
-    test_has_trivial_destructor<int>();
-    test_has_trivial_destructor<double>();
-    test_has_trivial_destructor<int*>();
-    test_has_trivial_destructor<const int*>();
-    test_has_trivial_destructor<char[3]>();
-    test_has_trivial_destructor<char[3]>();
-    test_has_trivial_destructor<bit_zero>();
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_assign.pass.cpp
deleted file mode 100644
index 268c1a6..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_assign.pass.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_trivial_move_assign
-
-#include <type_traits>
-
-int main()
-{
-#error has_trivial_move_assign not implemented
-}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_constructor.pass.cpp
deleted file mode 100644
index 5a47b14..0000000
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_constructor.pass.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-// has_trivial_move_constructor
-
-#include <type_traits>
-
-int main()
-{
-#error has_trivial_move_constructor not implemented
-}
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
new file mode 100644
index 0000000..d836e6a
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_assignable
+
+#include <type_traits>
+
+struct A
+{
+};
+
+struct B
+{
+    void operator=(A);
+};
+
+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), "");
+}
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 00b247b..40b15c4 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
@@ -14,25 +14,17 @@
 
 #include <type_traits>
 
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
-
 struct A
 {
     explicit A(int);
     A(int, double);
 };
 
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
-
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
-
     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), "");
-
-#endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE
 }
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
new file mode 100644
index 0000000..c44ba6d
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_copy_assignable
+
+#include <type_traits>
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+struct A
+{
+    A();
+};
+
+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), "");
+}
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
new file mode 100644
index 0000000..691ac69
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp
@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_copy_constructible
+
+#include <type_traits>
+
+template <class T, bool Result>
+void test_is_copy_constructible()
+{
+    static_assert(std::is_copy_constructible<T>::value == Result, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+public:
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    A(const A&);
+};
+
+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, true>();
+    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>();
+}
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
new file mode 100644
index 0000000..0830ce1
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_default_constructible
+
+#include <type_traits>
+
+template <class T, bool Result>
+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, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+public:
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    A();
+};
+
+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, true>();
+    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>();
+}
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
new file mode 100644
index 0000000..61b04b2
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_destructible
+
+#include <type_traits>
+
+template <class T, bool Result>
+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, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    ~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>();
+}
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
new file mode 100644
index 0000000..3f44f8e
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_move_assignable
+
+#include <type_traits>
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+struct A
+{
+    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&>::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), "");
+}
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
new file mode 100644
index 0000000..3ad3666
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_move_constructible
+
+#include <type_traits>
+
+template <class T, bool Result>
+void test_is_move_constructible()
+{
+    static_assert(std::is_move_constructible<T>::value == Result, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+public:
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    A(const A&);
+};
+
+struct B
+{
+    B(B&&);
+};
+
+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_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>();
+}
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
new file mode 100644
index 0000000..b571152
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_nothrow_assignable
+
+#include <type_traits>
+
+struct A
+{
+};
+
+struct B
+{
+    void operator=(A);
+};
+
+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), "");
+}
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 24c9ece..3dc73ce 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,8 +14,6 @@
 
 #include <type_traits>
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-
 class Empty
 {
 };
@@ -42,11 +40,11 @@
     A(const A&);
 };
 
-#endif  // _LIBCPP_HAS_NO_VARIADICS
-
 int main()
 {
-#ifndef _LIBCPP_HAS_NO_VARIADICS
-    static_assert((std::is_nothrow_constructible<int, const int>::value), "");
-#endif
+    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), "");
 }
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
similarity index 76%
rename from libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp
rename to libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
index f9947b8..b0fe063 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
@@ -9,14 +9,14 @@
 
 // type_traits
 
-// has_nothrow_copy_assign
+// is_nothrow_copy_assignable
 
 #include <type_traits>
 
 template <class T, bool Result>
 void test_has_nothrow_assign()
 {
-    static_assert(std::has_nothrow_copy_assign<T>::value == Result, "");
+    static_assert(std::is_nothrow_copy_assignable<T>::value == Result, "");
 }
 
 class Empty
@@ -35,11 +35,6 @@
     int :  0;
 };
 
-struct Abstract
-{
-    virtual ~Abstract() = 0;
-};
-
 struct A
 {
     A& operator=(const A&);
@@ -49,10 +44,7 @@
 {
     test_has_nothrow_assign<void, false>();
     test_has_nothrow_assign<A, false>();
-    test_has_nothrow_assign<int&, false>();
-    test_has_nothrow_assign<Abstract, false>();
-    test_has_nothrow_assign<char[3], false>();
-    test_has_nothrow_assign<char[], false>();
+    test_has_nothrow_assign<int&, true>();
 
     test_has_nothrow_assign<Union, true>();
     test_has_nothrow_assign<Empty, true>();
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
new file mode 100644
index 0000000..6bb5104
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_nothrow_copy_constructible
+
+#include <type_traits>
+
+template <class T>
+void test_is_nothrow_copy_constructible()
+{
+    static_assert( std::is_nothrow_copy_constructible<T>::value, "");
+    static_assert( std::is_nothrow_copy_constructible<const T>::value, "");
+    static_assert( std::is_nothrow_copy_constructible<volatile T>::value, "");
+    static_assert( std::is_nothrow_copy_constructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_has_not_nothrow_copy_constructor()
+{
+    static_assert(!std::is_nothrow_copy_constructible<T>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<const T>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<volatile T>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<const volatile T>::value, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+struct A
+{
+    A(const A&);
+};
+
+int main()
+{
+    test_has_not_nothrow_copy_constructor<void>();
+    test_has_not_nothrow_copy_constructor<A>();
+
+    test_is_nothrow_copy_constructible<int&>();
+    test_is_nothrow_copy_constructible<Union>();
+    test_is_nothrow_copy_constructible<Empty>();
+    test_is_nothrow_copy_constructible<int>();
+    test_is_nothrow_copy_constructible<double>();
+    test_is_nothrow_copy_constructible<int*>();
+    test_is_nothrow_copy_constructible<const int*>();
+    test_is_nothrow_copy_constructible<NotEmpty>();
+    test_is_nothrow_copy_constructible<bit_zero>();
+}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
new file mode 100644
index 0000000..84fb5f4
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_nothrow_default_constructible
+
+#include <type_traits>
+
+template <class T>
+void test_is_nothrow_default_constructible()
+{
+    static_assert( std::is_nothrow_default_constructible<T>::value, "");
+    static_assert( std::is_nothrow_default_constructible<const T>::value, "");
+    static_assert( std::is_nothrow_default_constructible<volatile T>::value, "");
+    static_assert( std::is_nothrow_default_constructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_has_not_nothrow_default_constructor()
+{
+    static_assert(!std::is_nothrow_default_constructible<T>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<const T>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<volatile T>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<const volatile T>::value, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+struct A
+{
+    A();
+};
+
+int main()
+{
+    test_has_not_nothrow_default_constructor<void>();
+    test_has_not_nothrow_default_constructor<int&>();
+    test_has_not_nothrow_default_constructor<A>();
+
+    test_is_nothrow_default_constructible<Union>();
+    test_is_nothrow_default_constructible<Empty>();
+    test_is_nothrow_default_constructible<int>();
+    test_is_nothrow_default_constructible<double>();
+    test_is_nothrow_default_constructible<int*>();
+    test_is_nothrow_default_constructible<const int*>();
+    test_is_nothrow_default_constructible<char[3]>();
+    test_is_nothrow_default_constructible<NotEmpty>();
+    test_is_nothrow_default_constructible<bit_zero>();
+}
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
new file mode 100644
index 0000000..dfa1b36
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_nothrow_destructible
+
+#include <type_traits>
+
+template <class T>
+void test_is_nothrow_destructible()
+{
+    static_assert( std::is_nothrow_destructible<T>::value, "");
+    static_assert( std::is_nothrow_destructible<const T>::value, "");
+    static_assert( std::is_nothrow_destructible<volatile T>::value, "");
+    static_assert( std::is_nothrow_destructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_has_not_nothrow_destructor()
+{
+    static_assert(!std::is_nothrow_destructible<T>::value, "");
+    static_assert(!std::is_nothrow_destructible<const T>::value, "");
+    static_assert(!std::is_nothrow_destructible<volatile T>::value, "");
+    static_assert(!std::is_nothrow_destructible<const volatile T>::value, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    ~A();
+};
+
+int main()
+{
+    test_has_not_nothrow_destructor<void>();
+    test_has_not_nothrow_destructor<A>();
+    test_has_not_nothrow_destructor<Abstract>();
+    test_has_not_nothrow_destructor<NotEmpty>();
+
+    test_is_nothrow_destructible<int&>();
+    test_is_nothrow_destructible<Union>();
+    test_is_nothrow_destructible<Empty>();
+    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]>();
+    test_is_nothrow_destructible<bit_zero>();
+}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
similarity index 76%
copy from libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp
copy to libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
index f9947b8..96a4a32 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp
@@ -9,14 +9,14 @@
 
 // type_traits
 
-// has_nothrow_copy_assign
+// has_nothrow_move_assign
 
 #include <type_traits>
 
 template <class T, bool Result>
 void test_has_nothrow_assign()
 {
-    static_assert(std::has_nothrow_copy_assign<T>::value == Result, "");
+    static_assert(std::is_nothrow_move_assignable<T>::value == Result, "");
 }
 
 class Empty
@@ -35,11 +35,6 @@
     int :  0;
 };
 
-struct Abstract
-{
-    virtual ~Abstract() = 0;
-};
-
 struct A
 {
     A& operator=(const A&);
@@ -49,10 +44,7 @@
 {
     test_has_nothrow_assign<void, false>();
     test_has_nothrow_assign<A, false>();
-    test_has_nothrow_assign<int&, false>();
-    test_has_nothrow_assign<Abstract, false>();
-    test_has_nothrow_assign<char[3], false>();
-    test_has_nothrow_assign<char[], false>();
+    test_has_nothrow_assign<int&, true>();
 
     test_has_nothrow_assign<Union, true>();
     test_has_nothrow_assign<Empty, true>();
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
new file mode 100644
index 0000000..fc52076
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// has_nothrow_move_constructor
+
+#include <type_traits>
+
+template <class T>
+void test_is_nothrow_move_constructible()
+{
+    static_assert( std::is_nothrow_move_constructible<T>::value, "");
+    static_assert( std::is_nothrow_move_constructible<const T>::value, "");
+    static_assert( std::is_nothrow_move_constructible<volatile T>::value, "");
+    static_assert( std::is_nothrow_move_constructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_has_not_nothrow_move_constructor()
+{
+    static_assert(!std::is_nothrow_move_constructible<T>::value, "");
+    static_assert(!std::is_nothrow_move_constructible<const T>::value, "");
+    static_assert(!std::is_nothrow_move_constructible<volatile T>::value, "");
+    static_assert(!std::is_nothrow_move_constructible<const volatile T>::value, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+struct A
+{
+    A(const A&);
+};
+
+int main()
+{
+    test_has_not_nothrow_move_constructor<void>();
+    test_has_not_nothrow_move_constructor<A>();
+
+    test_has_not_nothrow_move_constructor<int&>();
+    test_is_nothrow_move_constructible<Union>();
+    test_is_nothrow_move_constructible<Empty>();
+    test_is_nothrow_move_constructible<int>();
+    test_is_nothrow_move_constructible<double>();
+    test_is_nothrow_move_constructible<int*>();
+    test_is_nothrow_move_constructible<const int*>();
+    test_is_nothrow_move_constructible<NotEmpty>();
+    test_is_nothrow_move_constructible<bit_zero>();
+}
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
new file mode 100644
index 0000000..cd6d5d2
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_trivially_assignable
+
+#include <type_traits>
+
+struct A
+{
+};
+
+struct B
+{
+    void operator=(A);
+};
+
+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), "");
+}
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
new file mode 100644
index 0000000..ce0373b
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// template <class T, class... Args>
+//   struct is_trivially_constructible;
+
+#include <type_traits>
+
+struct A
+{
+    explicit A(int);
+    A(int, double);
+};
+
+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), "");
+}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
similarity index 83%
copy from libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp
copy to libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
index aa604a9..2ec06a0 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
@@ -9,14 +9,14 @@
 
 // type_traits
 
-// has_trivial_copy_assign
+// is_trivially_copy_assignable
 
 #include <type_traits>
 
 template <class T, bool Result>
 void test_has_trivial_assign()
 {
-    static_assert(std::has_trivial_copy_assign<T>::value == Result, "");
+    static_assert(std::is_trivially_copy_assignable<T>::value == Result, "");
 }
 
 class Empty
@@ -49,12 +49,10 @@
 {
     test_has_trivial_assign<void, false>();
     test_has_trivial_assign<A, false>();
-    test_has_trivial_assign<int&, 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<char[3], false>();
-    test_has_trivial_assign<char[], false>();
 
     test_has_trivial_assign<Union, true>();
     test_has_trivial_assign<Empty, true>();
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
new file mode 100644
index 0000000..45f6362
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_trivially_copy_constructible
+
+#include <type_traits>
+
+template <class T>
+void test_is_trivially_copy_constructible()
+{
+    static_assert( std::is_trivially_copy_constructible<T>::value, "");
+    static_assert( std::is_trivially_copy_constructible<const T>::value, "");
+    static_assert( std::is_trivially_copy_constructible<volatile T>::value, "");
+    static_assert( std::is_trivially_copy_constructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_has_not_trivial_copy_constructor()
+{
+    static_assert(!std::is_trivially_copy_constructible<T>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<const T>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<volatile T>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<const volatile T>::value, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+public:
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    A(const A&);
+};
+
+int main()
+{
+    test_has_not_trivial_copy_constructor<void>();
+    test_has_not_trivial_copy_constructor<A>();
+    test_has_not_trivial_copy_constructor<Abstract>();
+    test_has_not_trivial_copy_constructor<NotEmpty>();
+
+    test_is_trivially_copy_constructible<int&>();
+    test_is_trivially_copy_constructible<Union>();
+    test_is_trivially_copy_constructible<Empty>();
+    test_is_trivially_copy_constructible<int>();
+    test_is_trivially_copy_constructible<double>();
+    test_is_trivially_copy_constructible<int*>();
+    test_is_trivially_copy_constructible<const int*>();
+    test_is_trivially_copy_constructible<bit_zero>();
+}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
new file mode 100644
index 0000000..1f63401
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_trivially_default_constructible
+
+#include <type_traits>
+
+template <class T>
+void test_is_trivially_default_constructible()
+{
+    static_assert( std::is_trivially_default_constructible<T>::value, "");
+    static_assert( std::is_trivially_default_constructible<const T>::value, "");
+    static_assert( std::is_trivially_default_constructible<volatile T>::value, "");
+    static_assert( std::is_trivially_default_constructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_has_not_trivial_default_constructor()
+{
+    static_assert(!std::is_trivially_default_constructible<T>::value, "");
+    static_assert(!std::is_trivially_default_constructible<const T>::value, "");
+    static_assert(!std::is_trivially_default_constructible<volatile T>::value, "");
+    static_assert(!std::is_trivially_default_constructible<const volatile T>::value, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    A();
+};
+
+int main()
+{
+    test_has_not_trivial_default_constructor<void>();
+    test_has_not_trivial_default_constructor<int&>();
+    test_has_not_trivial_default_constructor<A>();
+    test_has_not_trivial_default_constructor<Abstract>();
+    test_has_not_trivial_default_constructor<NotEmpty>();
+
+    test_is_trivially_default_constructible<Union>();
+    test_is_trivially_default_constructible<Empty>();
+    test_is_trivially_default_constructible<int>();
+    test_is_trivially_default_constructible<double>();
+    test_is_trivially_default_constructible<int*>();
+    test_is_trivially_default_constructible<const int*>();
+    test_is_trivially_default_constructible<char[3]>();
+    test_is_trivially_default_constructible<bit_zero>();
+}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
new file mode 100644
index 0000000..ebe10e3
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_trivially_destructible
+
+#include <type_traits>
+
+template <class T>
+void test_is_trivially_destructible()
+{
+    static_assert( std::is_trivially_destructible<T>::value, "");
+    static_assert( std::is_trivially_destructible<const T>::value, "");
+    static_assert( std::is_trivially_destructible<volatile T>::value, "");
+    static_assert( std::is_trivially_destructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_has_not_trivial_destructor()
+{
+    static_assert(!std::is_trivially_destructible<T>::value, "");
+    static_assert(!std::is_trivially_destructible<const T>::value, "");
+    static_assert(!std::is_trivially_destructible<volatile T>::value, "");
+    static_assert(!std::is_trivially_destructible<const volatile T>::value, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    ~A();
+};
+
+int main()
+{
+    test_has_not_trivial_destructor<void>();
+    test_has_not_trivial_destructor<A>();
+    test_has_not_trivial_destructor<Abstract>();
+    test_has_not_trivial_destructor<NotEmpty>();
+
+    test_is_trivially_destructible<int&>();
+    test_is_trivially_destructible<Union>();
+    test_is_trivially_destructible<Empty>();
+    test_is_trivially_destructible<int>();
+    test_is_trivially_destructible<double>();
+    test_is_trivially_destructible<int*>();
+    test_is_trivially_destructible<const int*>();
+    test_is_trivially_destructible<char[3]>();
+    test_is_trivially_destructible<char[3]>();
+    test_is_trivially_destructible<bit_zero>();
+}
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
similarity index 83%
rename from libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp
rename to libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
index aa604a9..dcdaa25 100644
--- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp
@@ -9,14 +9,14 @@
 
 // type_traits
 
-// has_trivial_copy_assign
+// is_trivially_move_assignable
 
 #include <type_traits>
 
 template <class T, bool Result>
 void test_has_trivial_assign()
 {
-    static_assert(std::has_trivial_copy_assign<T>::value == Result, "");
+    static_assert(std::is_trivially_move_assignable<T>::value == Result, "");
 }
 
 class Empty
@@ -49,12 +49,10 @@
 {
     test_has_trivial_assign<void, false>();
     test_has_trivial_assign<A, false>();
-    test_has_trivial_assign<int&, 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<char[3], false>();
-    test_has_trivial_assign<char[], false>();
 
     test_has_trivial_assign<Union, true>();
     test_has_trivial_assign<Empty, true>();
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
new file mode 100644
index 0000000..a4fcbcb
--- /dev/null
+++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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
+
+// is_trivially_move_constructible
+
+#include <type_traits>
+
+template <class T>
+void test_is_trivially_move_constructible()
+{
+    static_assert( std::is_trivially_move_constructible<T>::value, "");
+    static_assert( std::is_trivially_move_constructible<const T>::value, "");
+    static_assert( std::is_trivially_move_constructible<volatile T>::value, "");
+    static_assert( std::is_trivially_move_constructible<const volatile T>::value, "");
+}
+
+template <class T>
+void test_has_not_trivial_move_constructor()
+{
+    static_assert(!std::is_trivially_move_constructible<T>::value, "");
+    static_assert(!std::is_trivially_move_constructible<const T>::value, "");
+    static_assert(!std::is_trivially_move_constructible<volatile T>::value, "");
+    static_assert(!std::is_trivially_move_constructible<const volatile T>::value, "");
+}
+
+class Empty
+{
+};
+
+class NotEmpty
+{
+public:
+    virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero
+{
+    int :  0;
+};
+
+class Abstract
+{
+public:
+    virtual ~Abstract() = 0;
+};
+
+struct A
+{
+    A(const A&);
+};
+
+int main()
+{
+    test_has_not_trivial_move_constructor<void>();
+    test_has_not_trivial_move_constructor<A>();
+    test_has_not_trivial_move_constructor<Abstract>();
+    test_has_not_trivial_move_constructor<NotEmpty>();
+
+    test_is_trivially_move_constructible<int&>();
+    test_is_trivially_move_constructible<Union>();
+    test_is_trivially_move_constructible<Empty>();
+    test_is_trivially_move_constructible<int>();
+    test_is_trivially_move_constructible<double>();
+    test_is_trivially_move_constructible<int*>();
+    test_is_trivially_move_constructible<const int*>();
+    test_is_trivially_move_constructible<bit_zero>();
+}