[PATCH] D116280: [clang] adds unary type trait checks as compiler built-ins

[Christopher Di Bella via Phabricator via cfe-commits]

cjdb updated this revision to Diff 465048.
cjdb added a comment.

uploading for archival purposes, will abandon the review in a moment


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D116280/new/

https://reviews.llvm.org/D116280

Files:
  clang/include/clang/Basic/DiagnosticSemaKinds.td
  clang/include/clang/Basic/TokenKinds.def
  clang/lib/Lex/PPMacroExpansion.cpp
  clang/lib/Parse/ParseDeclCXX.cpp
  clang/lib/Parse/ParseExpr.cpp
  clang/lib/Sema/SemaExprCXX.cpp
  clang/lib/Sema/SemaType.cpp
  clang/test/SemaCXX/deprecated-builtins.cpp
  clang/test/SemaCXX/type-traits.cpp


Index: clang/test/SemaCXX/type-traits.cpp
===================================================================
--- clang/test/SemaCXX/type-traits.cpp
+++ clang/test/SemaCXX/type-traits.cpp
@@ -345,11 +345,19 @@
 }
 
 typedef Enum EnumType;
+typedef EnumClass EnumClassType;
 
 void is_enum()
 {
   { int arr[T(__is_enum(Enum))]; }
   { int arr[T(__is_enum(EnumType))]; }
+  { int arr[T(__is_enum(SignedEnum))]; }
+  { int arr[T(__is_enum(UnsignedEnum))]; }
+
+  { int arr[T(__is_enum(EnumClass))]; }
+  { int arr[T(__is_enum(EnumClassType))]; }
+  { int arr[T(__is_enum(SignedEnumClass))]; }
+  { int arr[T(__is_enum(UnsignedEnumClass))]; }
 
   { int arr[F(__is_enum(int))]; }
   { int arr[F(__is_enum(Union))]; }
@@ -363,6 +371,29 @@
   { int arr[F(__is_enum(HasAnonymousUnion))]; }
 }
 
+void is_scoped_enum() {
+  { int arr[F(__is_scoped_enum(Enum))]; }
+  { int arr[F(__is_scoped_enum(EnumType))]; }
+  { int arr[F(__is_scoped_enum(SignedEnum))]; }
+  { int arr[F(__is_scoped_enum(UnsignedEnum))]; }
+
+  { int arr[T(__is_scoped_enum(EnumClass))]; }
+  { int arr[T(__is_scoped_enum(EnumClassType))]; }
+  { int arr[T(__is_scoped_enum(SignedEnumClass))]; }
+  { int arr[T(__is_scoped_enum(UnsignedEnumClass))]; }
+
+  { int arr[F(__is_scoped_enum(int))]; }
+  { int arr[F(__is_scoped_enum(Union))]; }
+  { int arr[F(__is_scoped_enum(Int))]; }
+  { int arr[F(__is_scoped_enum(IntAr))]; }
+  { int arr[F(__is_scoped_enum(UnionAr))]; }
+  { int arr[F(__is_scoped_enum(Derives))]; }
+  { int arr[F(__is_scoped_enum(ClassType))]; }
+  { int arr[F(__is_scoped_enum(cvoid))]; }
+  { int arr[F(__is_scoped_enum(IntArNB))]; }
+  { int arr[F(__is_scoped_enum(HasAnonymousUnion))]; }
+}
+
 struct FinalClass final {
 };
 
@@ -702,6 +733,106 @@
   int t31[F(__is_array(cvoid*))];
 }
 
+void is_bounded_array(int n) {
+  int t01[T(__is_bounded_array(IntAr))];
+  int t02[F(__is_bounded_array(IntArNB))];
+  int t03[T(__is_bounded_array(UnionAr))];
+
+  int t10[F(__is_bounded_array(void))];
+  int t11[F(__is_bounded_array(cvoid))];
+  int t12[F(__is_bounded_array(float))];
+  int t13[F(__is_bounded_array(double))];
+  int t14[F(__is_bounded_array(long double))];
+  int t15[F(__is_bounded_array(bool))];
+  int t16[F(__is_bounded_array(char))];
+  int t17[F(__is_bounded_array(signed char))];
+  int t18[F(__is_bounded_array(unsigned char))];
+  int t19[F(__is_bounded_array(wchar_t))];
+  int t20[F(__is_bounded_array(short))];
+  int t21[F(__is_bounded_array(unsigned short))];
+  int t22[F(__is_bounded_array(int))];
+  int t23[F(__is_bounded_array(unsigned int))];
+  int t24[F(__is_bounded_array(long))];
+  int t25[F(__is_bounded_array(unsigned long))];
+  int t26[F(__is_bounded_array(Union))];
+  int t27[F(__is_bounded_array(Derives))];
+  int t28[F(__is_bounded_array(ClassType))];
+  int t29[F(__is_bounded_array(Enum))];
+  int t30[F(__is_bounded_array(void *))];
+  int t31[F(__is_bounded_array(cvoid *))];
+
+  int t32[n];
+  (void)__is_bounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported for '__is_bounded_array'}}
+}
+
+void is_unbounded_array(int n) {
+  int t01[F(__is_unbounded_array(IntAr))];
+  int t02[T(__is_unbounded_array(IntArNB))];
+  int t03[F(__is_unbounded_array(UnionAr))];
+
+  int t10[F(__is_unbounded_array(void))];
+  int t11[F(__is_unbounded_array(cvoid))];
+  int t12[F(__is_unbounded_array(float))];
+  int t13[F(__is_unbounded_array(double))];
+  int t14[F(__is_unbounded_array(long double))];
+  int t15[F(__is_unbounded_array(bool))];
+  int t16[F(__is_unbounded_array(char))];
+  int t17[F(__is_unbounded_array(signed char))];
+  int t18[F(__is_unbounded_array(unsigned char))];
+  int t19[F(__is_unbounded_array(wchar_t))];
+  int t20[F(__is_unbounded_array(short))];
+  int t21[F(__is_unbounded_array(unsigned short))];
+  int t22[F(__is_unbounded_array(int))];
+  int t23[F(__is_unbounded_array(unsigned int))];
+  int t24[F(__is_unbounded_array(long))];
+  int t25[F(__is_unbounded_array(unsigned long))];
+  int t26[F(__is_unbounded_array(Union))];
+  int t27[F(__is_unbounded_array(Derives))];
+  int t28[F(__is_unbounded_array(ClassType))];
+  int t29[F(__is_unbounded_array(Enum))];
+  int t30[F(__is_unbounded_array(void *))];
+  int t31[F(__is_unbounded_array(cvoid *))];
+
+  int t32[n];
+  (void)__is_unbounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported for '__is_unbounded_array'}}
+}
+
+void is_referenceable() {
+  { int a[T(__is_referenceable(int))]; }
+  { int a[T(__is_referenceable(const int))]; }
+  { int a[T(__is_referenceable(volatile int))]; }
+  { int a[T(__is_referenceable(const volatile int))]; }
+  { int a[T(__is_referenceable(int *))]; }
+  { int a[T(__is_referenceable(int &))]; }
+  { int a[T(__is_referenceable(int &&))]; }
+  { int a[T(__is_referenceable(int (*)()))]; }
+  { int a[T(__is_referenceable(int (&)()))]; }
+  { int a[T(__is_referenceable(int(&&)()))]; }
+  { int a[T(__is_referenceable(IntAr))]; }
+  { int a[T(__is_referenceable(IntArNB))]; }
+  { int a[T(__is_referenceable(decltype(nullptr)))]; }
+  { int a[T(__is_referenceable(Empty))]; }
+  { int a[T(__is_referenceable(Union))]; }
+  { int a[T(__is_referenceable(Derives))]; }
+  { int a[T(__is_referenceable(Enum))]; }
+  { int a[T(__is_referenceable(EnumClass))]; }
+  { int a[T(__is_referenceable(int Empty::*))]; }
+  { int a[T(__is_referenceable(int(Empty::*)()))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() volatile))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const volatile))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() &))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const &))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() volatile &))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const volatile &))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() &&))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const &&))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() volatile &&))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const volatile &&))]; }
+
+  { int a[F(__is_referenceable(void))]; }
+}
+
 template <typename T> void tmpl_func(T&) {}
 
 template <typename T> struct type_wrapper {
@@ -934,6 +1065,42 @@
   int t34[F(__is_pointer(void (StructWithMembers::*) ()))];
 }
 
+void is_null_pointer() {
+  StructWithMembers x;
+
+  int t00[T(__is_nullptr(decltype(nullptr)))];
+  int t01[F(__is_nullptr(void *))];
+  int t02[F(__is_nullptr(cvoid *))];
+  int t03[F(__is_nullptr(cvoid *))];
+  int t04[F(__is_nullptr(char *))];
+  int t05[F(__is_nullptr(int *))];
+  int t06[F(__is_nullptr(int **))];
+  int t07[F(__is_nullptr(ClassType *))];
+  int t08[F(__is_nullptr(Derives *))];
+  int t09[F(__is_nullptr(Enum *))];
+  int t10[F(__is_nullptr(IntArNB *))];
+  int t11[F(__is_nullptr(Union *))];
+  int t12[F(__is_nullptr(UnionAr *))];
+  int t13[F(__is_nullptr(StructWithMembers *))];
+  int t14[F(__is_nullptr(void (*)()))];
+
+  int t20[F(__is_nullptr(void))];
+  int t21[F(__is_nullptr(cvoid))];
+  int t22[F(__is_nullptr(cvoid))];
+  int t23[F(__is_nullptr(char))];
+  int t24[F(__is_nullptr(int))];
+  int t25[F(__is_nullptr(int))];
+  int t26[F(__is_nullptr(ClassType))];
+  int t27[F(__is_nullptr(Derives))];
+  int t28[F(__is_nullptr(Enum))];
+  int t29[F(__is_nullptr(IntArNB))];
+  int t30[F(__is_nullptr(Union))];
+  int t31[F(__is_nullptr(UnionAr))];
+  int t32[F(__is_nullptr(StructWithMembers))];
+  int t33[F(__is_nullptr(int StructWithMembers::*))];
+  int t34[F(__is_nullptr(void(StructWithMembers::*)()))];
+}
+
 void is_member_object_pointer()
 {
   StructWithMembers x;
@@ -1481,8 +1648,8 @@
 typedef const IntAr ConstIntAr;
 typedef ConstIntAr ConstIntArAr[4];
 
-struct HasCopy {
-  HasCopy(HasCopy& cp);
+struct HasMutableCopyCtor {
+  HasMutableCopyCtor(HasMutableCopyCtor &cp);
 };
 
 struct HasMove {
@@ -1518,7 +1685,7 @@
   { int arr[F(__has_trivial_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
   { int arr[F(__has_trivial_constructor(HasCons))]; }
   { int arr[F(__has_trivial_constructor(HasRef))]; }
-  { int arr[F(__has_trivial_constructor(HasCopy))]; }
+  { int arr[F(__has_trivial_constructor(HasMutableCopyCtor))]; }
   { int arr[F(__has_trivial_constructor(IntRef))]; }
   { int arr[F(__has_trivial_constructor(VirtAr))]; }
   { int arr[F(__has_trivial_constructor(void))]; }
@@ -1581,7 +1748,7 @@
   { int arr[T(__has_trivial_copy(ACompleteType[]))]; }
 
   { int arr[F(__has_trivial_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
-  { int arr[F(__has_trivial_copy(HasCopy))]; }
+  { int arr[F(__has_trivial_copy(HasMutableCopyCtor))]; }
   { int arr[F(__has_trivial_copy(HasTemplateCons))]; }
   { int arr[F(__has_trivial_copy(VirtAr))]; }
   { int arr[F(__has_trivial_copy(void))]; }
@@ -1601,7 +1768,7 @@
   { int arr[T(__has_trivial_assign(HasPriv))]; }
   { int arr[T(__has_trivial_assign(HasCons))]; }
   { int arr[T(__has_trivial_assign(HasRef))]; }
-  { int arr[T(__has_trivial_assign(HasCopy))]; }
+  { int arr[T(__has_trivial_assign(HasMutableCopyCtor))]; }
   { int arr[T(__has_trivial_assign(HasMove))]; }
   { int arr[T(__has_trivial_assign(HasMoveAssign))]; }
   { int arr[T(__has_trivial_assign(AllDefaulted))]; }
@@ -1635,7 +1802,7 @@
   { int arr[T(__has_trivial_destructor(HasPriv))]; }
   { int arr[T(__has_trivial_destructor(HasCons))]; }
   { int arr[T(__has_trivial_destructor(HasRef))]; }
-  { int arr[T(__has_trivial_destructor(HasCopy))]; }
+  { int arr[T(__has_trivial_destructor(HasMutableCopyCtor))]; }
   { int arr[T(__has_trivial_destructor(HasMove))]; }
   { int arr[T(__has_trivial_destructor(IntRef))]; }
   { int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
@@ -1692,7 +1859,7 @@
   { int arr[T(__has_nothrow_assign(HasPriv))]; }
   { int arr[T(__has_nothrow_assign(HasCons))]; }
   { int arr[T(__has_nothrow_assign(HasRef))]; }
-  { int arr[T(__has_nothrow_assign(HasCopy))]; }
+  { int arr[T(__has_nothrow_assign(HasMutableCopyCtor))]; }
   { int arr[T(__has_nothrow_assign(HasMove))]; }
   { int arr[T(__has_nothrow_assign(HasMoveAssign))]; }
   { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
@@ -1801,7 +1968,7 @@
   { int arr[T(__has_nothrow_copy(ACompleteType[]))]; }
 
   { int arr[F(__has_nothrow_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
-  { int arr[F(__has_nothrow_copy(HasCopy))]; }
+  { int arr[F(__has_nothrow_copy(HasMutableCopyCtor))]; }
   { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
   { int arr[F(__has_nothrow_copy(VirtAr))]; }
   { int arr[F(__has_nothrow_copy(void))]; }
@@ -1831,7 +1998,7 @@
   { int arr[F(__has_nothrow_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
   { int arr[F(__has_nothrow_constructor(HasCons))]; }
   { int arr[F(__has_nothrow_constructor(HasRef))]; }
-  { int arr[F(__has_nothrow_constructor(HasCopy))]; }
+  { int arr[F(__has_nothrow_constructor(HasMutableCopyCtor))]; }
   { int arr[F(__has_nothrow_constructor(HasMove))]; }
   { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
   { int arr[F(__has_nothrow_constructor(IntRef))]; }
@@ -1858,7 +2025,7 @@
   { int arr[F(__has_virtual_destructor(HasPriv))]; }
   { int arr[F(__has_virtual_destructor(HasCons))]; }
   { int arr[F(__has_virtual_destructor(HasRef))]; }
-  { int arr[F(__has_virtual_destructor(HasCopy))]; }
+  { int arr[F(__has_virtual_destructor(HasMutableCopyCtor))]; }
   { int arr[F(__has_virtual_destructor(HasMove))]; }
   { int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
   { int arr[F(__has_virtual_destructor(HasMoveAssign))]; }
@@ -2325,6 +2492,1137 @@
   { int arr[F(__is_nothrow_constructible(const volatile void))]; }
 }
 
+struct VolatileCopyCtor {
+  VolatileCopyCtor(volatile VolatileCopyCtor &);
+};
+
+struct CVCopyCtor {
+  CVCopyCtor(const volatile CVCopyCtor &);
+};
+
+struct CopyCtorDeleted {
+  CopyCtorDeleted(const CopyCtorDeleted &) = delete;
+};
+
+struct BaseDeletedCopyCtor : CopyCtorDeleted {};
+
+struct MemberDeletedCopyCtor {
+  CopyCtorDeleted x;
+};
+
+void copy_constructible_checks() {
+  // Builtin types
+
+  { int arr[T(__is_copy_constructible(int))]; }
+  { int arr[T(__is_copy_constructible(const int))]; }
+  { int arr[T(__is_copy_constructible(volatile int))]; }
+  { int arr[T(__is_copy_constructible(const volatile int))]; }
+  { int arr[T(__is_copy_constructible(int&))]; }
+  { int arr[T(__is_copy_constructible(const int&))]; }
+  { int arr[T(__is_copy_constructible(volatile int&))]; }
+  { int arr[T(__is_copy_constructible(const volatile int&))]; }
+  { int arr[F(__is_copy_constructible(int&&))]; }
+  { int arr[F(__is_copy_constructible(const int&&))]; }
+  { int arr[F(__is_copy_constructible(volatile int&&))]; }
+  { int arr[F(__is_copy_constructible(const volatile int&&))]; }
+  { int arr[T(__is_copy_constructible(int*))]; }
+  { int arr[T(__is_copy_constructible(int* const))]; }
+  { int arr[T(__is_copy_constructible(int* volatile))]; }
+  { int arr[T(__is_copy_constructible(int* const volatile))]; }
+  { int arr[F(__is_copy_constructible(int[2]))]; }
+  { int arr[F(__is_copy_constructible(int[]))]; }
+  { int arr[T(__is_copy_constructible(decltype(nullptr)))]; }
+  { int arr[T(__is_copy_constructible(void(*)()))]; }
+  { int arr[T(__is_copy_constructible(void(&)()))]; }
+  { int arr[T(__is_copy_constructible(int Empty::*))]; }
+  { int arr[T(__is_copy_constructible(int (Empty::*)()))]; }
+
+  // // User-defined types
+  { int arr[T(__is_copy_constructible(AllDefaulted))]; };
+  { int arr[T(__is_copy_constructible(const AllDefaulted))]; };
+  { int arr[F(__is_copy_constructible(volatile AllDefaulted))]; };
+  { int arr[F(__is_copy_constructible(const volatile AllDefaulted))]; };
+
+  { int arr[T(__is_copy_constructible(AllDefaulted))]; };
+  { int arr[T(__is_copy_constructible(const AllDefaulted))]; };
+  { int arr[F(__is_copy_constructible(volatile AllDefaulted))]; };
+  { int arr[F(__is_copy_constructible(const volatile AllDefaulted))]; };
+
+  { int arr[T(__is_copy_constructible(CEmptyStruct))]; };
+  { int arr[T(__is_copy_constructible(const CEmptyStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile CEmptyStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile CEmptyStruct))]; };
+
+  { int arr[T(__is_copy_constructible(CppEmptyStruct))]; };
+  { int arr[T(__is_copy_constructible(const CppEmptyStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile CppEmptyStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppEmptyStruct))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardBy2ndVirtBase))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardBy2ndVirtBase))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardBy2ndVirtBase))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardBy2ndVirtBase))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByBase))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByBase))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByBase))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByBase))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByMemb))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByMemb))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByMemb))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByMemb))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByProt))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByProt))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByProt))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByProt))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardBySameBase))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardBySameBase))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardBySameBase))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardBySameBase))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByVirt))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByVirt))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByVirt))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByVirt))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByVirtBase))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByVirtBase))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByVirtBase))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByVirtBase))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructStandard))]; };
+  { int arr[T(__is_copy_constructible(const CppStructStandard))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructStandard))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructStandard))]; };
+
+  { int arr[T(__is_copy_constructible(CStruct))]; };
+  { int arr[T(__is_copy_constructible(const CStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile CStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile CStruct))]; };
+
+  { int arr[T(__is_copy_constructible(CVCopyCtor))]; };
+  { int arr[T(__is_copy_constructible(const CVCopyCtor))]; };
+  { int arr[T(__is_copy_constructible(volatile CVCopyCtor))]; };
+  { int arr[T(__is_copy_constructible(const volatile CVCopyCtor))]; };
+
+  { int arr[T(__is_copy_constructible(Derives))]; };
+  { int arr[T(__is_copy_constructible(const Derives))]; };
+  { int arr[F(__is_copy_constructible(volatile Derives))]; };
+  { int arr[F(__is_copy_constructible(const volatile Derives))]; };
+
+  { int arr[T(__is_copy_constructible(DerivesHasRef))]; };
+  { int arr[T(__is_copy_constructible(const DerivesHasRef))]; };
+  { int arr[F(__is_copy_constructible(volatile DerivesHasRef))]; };
+  { int arr[F(__is_copy_constructible(const volatile DerivesHasRef))]; };
+
+  { int arr[T(__is_copy_constructible(Empty))]; };
+  { int arr[T(__is_copy_constructible(const Empty))]; };
+  { int arr[F(__is_copy_constructible(volatile Empty))]; };
+  { int arr[F(__is_copy_constructible(const volatile Empty))]; };
+
+  { int arr[T(__is_copy_constructible(EmptyUnion))]; };
+  { int arr[T(__is_copy_constructible(const EmptyUnion))]; };
+  { int arr[F(__is_copy_constructible(volatile EmptyUnion))]; };
+  { int arr[F(__is_copy_constructible(const volatile EmptyUnion))]; };
+
+  { int arr[T(__is_copy_constructible(Enum))]; };
+  { int arr[T(__is_copy_constructible(const Enum))]; };
+  { int arr[T(__is_copy_constructible(volatile Enum))]; };
+  { int arr[T(__is_copy_constructible(const volatile Enum))]; };
+
+  { int arr[T(__is_copy_constructible(EnumClass))]; };
+  { int arr[T(__is_copy_constructible(const EnumClass))]; };
+  { int arr[T(__is_copy_constructible(volatile EnumClass))]; };
+  { int arr[T(__is_copy_constructible(const volatile EnumClass))]; };
+
+  { int arr[T(__is_copy_constructible(ExtDefaulted))]; };
+  { int arr[T(__is_copy_constructible(const ExtDefaulted))]; };
+  { int arr[F(__is_copy_constructible(volatile ExtDefaulted))]; };
+  { int arr[F(__is_copy_constructible(const volatile ExtDefaulted))]; };
+
+  { int arr[T(__is_copy_constructible(ExtDefaulted))]; };
+  { int arr[T(__is_copy_constructible(const ExtDefaulted))]; };
+  { int arr[F(__is_copy_constructible(volatile ExtDefaulted))]; };
+  { int arr[F(__is_copy_constructible(const volatile ExtDefaulted))]; };
+
+  { int arr[T(__is_copy_constructible(HasCons))]; };
+  { int arr[T(__is_copy_constructible(const HasCons))]; };
+  { int arr[F(__is_copy_constructible(volatile HasCons))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasCons))]; };
+
+  { int arr[T(__is_copy_constructible(HasCopyAssign))]; };
+  { int arr[T(__is_copy_constructible(const HasCopyAssign))]; };
+  { int arr[F(__is_copy_constructible(volatile HasCopyAssign))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasCopyAssign))]; };
+
+  { int arr[T(__is_copy_constructible(HasDest))]; };
+  { int arr[T(__is_copy_constructible(const HasDest))]; };
+  { int arr[F(__is_copy_constructible(volatile HasDest))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasDest))]; };
+
+  { int arr[T(__is_copy_constructible(HasMultipleCopy))]; };
+  { int arr[T(__is_copy_constructible(const HasMultipleCopy))]; };
+  { int arr[F(__is_copy_constructible(volatile HasMultipleCopy))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasMultipleCopy))]; };
+
+  { int arr[T(__is_copy_constructible(HasPriv))]; };
+  { int arr[T(__is_copy_constructible(const HasPriv))]; };
+  { int arr[F(__is_copy_constructible(volatile HasPriv))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasPriv))]; };
+
+  { int arr[T(__is_copy_constructible(HasRef))]; };
+  { int arr[T(__is_copy_constructible(const HasRef))]; };
+  { int arr[F(__is_copy_constructible(volatile HasRef))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasRef))]; };
+
+  { int arr[T(__is_copy_constructible(HasTemplateCons))]; };
+  { int arr[T(__is_copy_constructible(const HasTemplateCons))]; };
+  { int arr[T(__is_copy_constructible(volatile HasTemplateCons))]; };
+  { int arr[T(__is_copy_constructible(const volatile HasTemplateCons))]; };
+
+  { int arr[T(__is_copy_constructible(NoDefaultMoveAssignDueToDtor))]; };
+  { int arr[T(__is_copy_constructible(const NoDefaultMoveAssignDueToDtor))]; };
+  { int arr[F(__is_copy_constructible(volatile NoDefaultMoveAssignDueToDtor))]; };
+  { int arr[F(__is_copy_constructible(const volatile NoDefaultMoveAssignDueToDtor))]; };
+
+  { int arr[T(__is_copy_constructible(NoDefaultMoveAssignDueToUDCopyAssign))]; };
+  { int arr[T(__is_copy_constructible(const NoDefaultMoveAssignDueToUDCopyAssign))]; };
+  { int arr[F(__is_copy_constructible(volatile NoDefaultMoveAssignDueToUDCopyAssign))]; };
+  { int arr[F(__is_copy_constructible(const volatile NoDefaultMoveAssignDueToUDCopyAssign))]; };
+
+  { int arr[T(__is_copy_constructible(NoDefaultMoveAssignDueToUDCopyCtor))]; };
+  { int arr[T(__is_copy_constructible(const NoDefaultMoveAssignDueToUDCopyCtor))]; };
+  { int arr[F(__is_copy_constructible(volatile NoDefaultMoveAssignDueToUDCopyCtor))]; };
+  { int arr[F(__is_copy_constructible(const volatile NoDefaultMoveAssignDueToUDCopyCtor))]; };
+
+  { int arr[T(__is_copy_constructible(NonTCStruct))]; };
+  { int arr[T(__is_copy_constructible(const NonTCStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile NonTCStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile NonTCStruct))]; };
+
+  { int arr[T(__is_copy_constructible(NonTrivialStruct))]; };
+  { int arr[T(__is_copy_constructible(const NonTrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile NonTrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile NonTrivialStruct))]; };
+
+  { int arr[T(__is_copy_constructible(POD))]; };
+  { int arr[T(__is_copy_constructible(const POD))]; };
+  { int arr[F(__is_copy_constructible(volatile POD))]; };
+  { int arr[F(__is_copy_constructible(const volatile POD))]; };
+
+  { int arr[T(__is_copy_constructible(SuperNonTrivialStruct))]; };
+  { int arr[T(__is_copy_constructible(const SuperNonTrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile SuperNonTrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile SuperNonTrivialStruct))]; };
+
+  { int arr[T(__is_copy_constructible(TrivialStruct))]; };
+  { int arr[T(__is_copy_constructible(const TrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile TrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile TrivialStruct))]; };
+
+  { int arr[T(__is_copy_constructible(Union))]; };
+  { int arr[T(__is_copy_constructible(const Union))]; };
+  { int arr[F(__is_copy_constructible(volatile Union))]; };
+  { int arr[F(__is_copy_constructible(const volatile Union))]; };
+
+
+  { int arr[F(__is_copy_constructible(AllDeleted))]; }
+  { int arr[F(__is_copy_constructible(const AllDeleted))]; }
+  { int arr[F(__is_copy_constructible(volatile AllDeleted))]; }
+  { int arr[F(__is_copy_constructible(const volatile AllDeleted))]; }
+  { int arr[F(__is_copy_constructible(AllPrivate))]; }
+  { int arr[F(__is_copy_constructible(const AllPrivate))]; }
+  { int arr[F(__is_copy_constructible(volatile AllPrivate))]; }
+  { int arr[F(__is_copy_constructible(const volatile AllPrivate))]; }
+  { int arr[F(__is_copy_constructible(AnIncompleteType[]))]; }
+  { int arr[F(__is_copy_constructible(const AnIncompleteType[]))]; }
+  { int arr[F(__is_copy_constructible(volatile AnIncompleteType[]))]; }
+  { int arr[F(__is_copy_constructible(const volatile AnIncompleteType[]))]; }
+  { int arr[F(__is_copy_constructible(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_copy_constructible(const AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_copy_constructible(volatile AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_copy_constructible(const volatile AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_copy_constructible(BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(volatile BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const volatile BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(CopyCtorDeleted))]; }
+  { int arr[F(__is_copy_constructible(const CopyCtorDeleted))]; }
+  { int arr[F(__is_copy_constructible(volatile CopyCtorDeleted))]; }
+  { int arr[F(__is_copy_constructible(const volatile CopyCtorDeleted))]; }
+  { int arr[F(__is_copy_constructible(HasMutableCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const HasMutableCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(volatile HasMutableCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const volatile HasMutableCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(HasMove))]; }
+  { int arr[F(__is_copy_constructible(const HasMove))]; }
+  { int arr[F(__is_copy_constructible(volatile HasMove))]; }
+  { int arr[F(__is_copy_constructible(const volatile HasMove))]; }
+  { int arr[F(__is_copy_constructible(HasMoveAssign))]; }
+  { int arr[F(__is_copy_constructible(const HasMoveAssign))]; }
+  { int arr[F(__is_copy_constructible(volatile HasMoveAssign))]; }
+  { int arr[F(__is_copy_constructible(const volatile HasMoveAssign))]; }
+  { int arr[F(__is_copy_constructible(MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(volatile MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const volatile MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(VirtAr))]; }
+  { int arr[F(__is_copy_constructible(const VirtAr))]; }
+  { int arr[F(__is_copy_constructible(volatile VirtAr))]; }
+  { int arr[F(__is_copy_constructible(const volatile VirtAr))]; }
+  { int arr[F(__is_copy_constructible(VolatileCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const VolatileCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(volatile VolatileCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const volatile VolatileCopyCtor))]; }
+
+  // Non-referencable types
+  { int arr[F(__is_copy_constructible(void))]; }
+  { int arr[F(__is_copy_constructible(void()))]; }
+}
+
+struct ConstMoveCtor {
+  ConstMoveCtor(const ConstMoveCtor &&);
+};
+
+struct VolatileMoveCtor {
+  VolatileMoveCtor(volatile VolatileMoveCtor &&);
+};
+
+struct CVMoveCtor {
+  CVMoveCtor(const volatile CVMoveCtor &&);
+};
+
+struct MoveCtorDeleted {
+  MoveCtorDeleted(MoveCtorDeleted &&) = delete;
+};
+
+struct BaseDeletedMoveCtor : MoveCtorDeleted {};
+
+struct MemberDeletedMoveCtor {
+  MoveCtorDeleted x;
+};
+
+void move_constructible_checks() {
+  // Builtin types
+  { int arr[T(__is_move_constructible(int))]; }
+  { int arr[T(__is_move_constructible(const int))]; }
+  { int arr[T(__is_move_constructible(volatile int))]; }
+  { int arr[T(__is_move_constructible(const volatile int))]; }
+  { int arr[T(__is_move_constructible(int&))]; }
+  { int arr[T(__is_move_constructible(const int&))]; }
+  { int arr[T(__is_move_constructible(volatile int&))]; }
+  { int arr[T(__is_move_constructible(const volatile int&))]; }
+  { int arr[T(__is_move_constructible(int&&))]; }
+  { int arr[T(__is_move_constructible(const int&&))]; }
+  { int arr[T(__is_move_constructible(volatile int&&))]; }
+  { int arr[T(__is_move_constructible(const volatile int&&))]; }
+  { int arr[T(__is_move_constructible(int*))]; }
+  { int arr[T(__is_move_constructible(int* const))]; }
+  { int arr[T(__is_move_constructible(int* volatile))]; }
+  { int arr[T(__is_move_constructible(int* const volatile))]; }
+  { int arr[F(__is_move_constructible(int[5]))]; }
+  { int arr[F(__is_move_constructible(int[]))]; }
+  { int arr[T(__is_move_constructible(decltype(nullptr)))]; }
+  { int arr[T(__is_move_constructible(void (*)()))]; }
+  { int arr[T(__is_move_constructible(void (&)()))]; }
+  { int arr[T(__is_move_constructible(int Empty::*))]; }
+
+  // // User-defined types
+  { int arr[T(__is_move_constructible(AllDefaulted))]; }
+  { int arr[T(__is_move_constructible(const AllDefaulted))]; }
+  { int arr[F(__is_move_constructible(volatile AllDefaulted))]; }
+  { int arr[F(__is_move_constructible(const volatile AllDefaulted))]; }
+  { int arr[T(__is_move_constructible(AllDefaulted))]; }
+  { int arr[T(__is_move_constructible(const AllDefaulted))]; }
+  { int arr[F(__is_move_constructible(volatile AllDefaulted))]; }
+  { int arr[F(__is_move_constructible(const volatile AllDefaulted))]; }
+  { int arr[T(__is_move_constructible(CEmptyStruct))]; }
+  { int arr[T(__is_move_constructible(const CEmptyStruct))]; }
+  { int arr[F(__is_move_constructible(volatile CEmptyStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile CEmptyStruct))]; }
+  { int arr[T(__is_move_constructible(ConstMoveCtor))]; }
+  { int arr[T(__is_move_constructible(const ConstMoveCtor))]; }
+  { int arr[F(__is_move_constructible(volatile ConstMoveCtor))]; }
+  { int arr[F(__is_move_constructible(const volatile ConstMoveCtor))]; }
+  { int arr[T(__is_move_constructible(CppEmptyStruct))]; }
+  { int arr[T(__is_move_constructible(const CppEmptyStruct))]; }
+  { int arr[F(__is_move_constructible(volatile CppEmptyStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile CppEmptyStruct))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardBy2ndVirtBase))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardBy2ndVirtBase))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardBy2ndVirtBase))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardBy2ndVirtBase))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByBase))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByBase))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByBase))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByBase))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByMemb))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByMemb))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByMemb))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByMemb))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByProt))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByProt))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByProt))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByProt))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardBySameBase))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardBySameBase))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardBySameBase))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardBySameBase))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByVirt))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByVirt))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByVirt))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByVirt))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByVirtBase))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByVirtBase))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByVirtBase))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByVirtBase))]; }
+  { int arr[T(__is_move_constructible(CppStructStandard))]; }
+  { int arr[T(__is_move_constructible(const CppStructStandard))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructStandard))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructStandard))]; }
+  { int arr[T(__is_move_constructible(CStruct))]; }
+  { int arr[T(__is_move_constructible(const CStruct))]; }
+  { int arr[F(__is_move_constructible(volatile CStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile CStruct))]; }
+  { int arr[T(__is_move_constructible(CVMoveCtor))]; }
+  { int arr[T(__is_move_constructible(const CVMoveCtor))]; }
+  { int arr[T(__is_move_constructible(volatile CVMoveCtor))]; }
+  { int arr[T(__is_move_constructible(const volatile CVMoveCtor))]; }
+  { int arr[T(__is_move_constructible(Derives))]; }
+  { int arr[T(__is_move_constructible(const Derives))]; }
+  { int arr[F(__is_move_constructible(volatile Derives))]; }
+  { int arr[F(__is_move_constructible(const volatile Derives))]; }
+  { int arr[T(__is_move_constructible(DerivesHasRef))]; }
+  { int arr[T(__is_move_constructible(const DerivesHasRef))]; }
+  { int arr[F(__is_move_constructible(volatile DerivesHasRef))]; }
+  { int arr[F(__is_move_constructible(const volatile DerivesHasRef))]; }
+  { int arr[T(__is_move_constructible(Empty))]; }
+  { int arr[T(__is_move_constructible(const Empty))]; }
+  { int arr[F(__is_move_constructible(volatile Empty))]; }
+  { int arr[F(__is_move_constructible(const volatile Empty))]; }
+  { int arr[T(__is_move_constructible(EmptyUnion))]; }
+  { int arr[T(__is_move_constructible(const EmptyUnion))]; }
+  { int arr[F(__is_move_constructible(volatile EmptyUnion))]; }
+  { int arr[F(__is_move_constructible(const volatile EmptyUnion))]; }
+  { int arr[T(__is_move_constructible(Enum))]; }
+  { int arr[T(__is_move_constructible(const Enum))]; }
+  { int arr[T(__is_move_constructible(volatile Enum))]; }
+  { int arr[T(__is_move_constructible(const volatile Enum))]; }
+  { int arr[T(__is_move_constructible(EnumClass))]; }
+  { int arr[T(__is_move_constructible(const EnumClass))]; }
+  { int arr[T(__is_move_constructible(volatile EnumClass))]; }
+  { int arr[T(__is_move_constructible(const volatile EnumClass))]; }
+  { int arr[T(__is_move_constructible(ExtDefaulted))]; }
+  { int arr[T(__is_move_constructible(const ExtDefaulted))]; }
+  { int arr[F(__is_move_constructible(volatile ExtDefaulted))]; }
+  { int arr[F(__is_move_constructible(const volatile ExtDefaulted))]; }
+  { int arr[T(__is_move_constructible(ExtDefaulted))]; }
+  { int arr[T(__is_move_constructible(const ExtDefaulted))]; }
+  { int arr[F(__is_move_constructible(volatile ExtDefaulted))]; }
+  { int arr[F(__is_move_constructible(const volatile ExtDefaulted))]; }
+  { int arr[T(__is_move_constructible(HasCons))]; }
+  { int arr[T(__is_move_constructible(const HasCons))]; }
+  { int arr[F(__is_move_constructible(volatile HasCons))]; }
+  { int arr[F(__is_move_constructible(const volatile HasCons))]; }
+  { int arr[T(__is_move_constructible(HasCopyAssign))]; }
+  { int arr[T(__is_move_constructible(const HasCopyAssign))]; }
+  { int arr[F(__is_move_constructible(volatile HasCopyAssign))]; }
+  { int arr[F(__is_move_constructible(const volatile HasCopyAssign))]; }
+  { int arr[T(__is_move_constructible(HasDest))]; }
+  { int arr[T(__is_move_constructible(const HasDest))]; }
+  { int arr[F(__is_move_constructible(volatile HasDest))]; }
+  { int arr[F(__is_move_constructible(const volatile HasDest))]; }
+  { int arr[T(__is_move_constructible(HasMove))]; }
+  { int arr[F(__is_move_constructible(const HasMove))]; }
+  { int arr[F(__is_move_constructible(volatile HasMove))]; }
+  { int arr[F(__is_move_constructible(const volatile HasMove))]; }
+  { int arr[T(__is_move_constructible(HasPriv))]; }
+  { int arr[T(__is_move_constructible(const HasPriv))]; }
+  { int arr[F(__is_move_constructible(volatile HasPriv))]; }
+  { int arr[F(__is_move_constructible(const volatile HasPriv))]; }
+  { int arr[T(__is_move_constructible(HasRef))]; }
+  { int arr[T(__is_move_constructible(const HasRef))]; }
+  { int arr[F(__is_move_constructible(volatile HasRef))]; }
+  { int arr[F(__is_move_constructible(const volatile HasRef))]; }
+  { int arr[T(__is_move_constructible(HasTemplateCons))]; }
+  { int arr[T(__is_move_constructible(const HasTemplateCons))]; }
+  { int arr[F(__is_move_constructible(volatile HasTemplateCons))]; }
+  { int arr[F(__is_move_constructible(const volatile HasTemplateCons))]; }
+  { int arr[T(__is_move_constructible(NoDefaultMoveAssignDueToDtor))]; }
+  { int arr[T(__is_move_constructible(const NoDefaultMoveAssignDueToDtor))]; }
+  { int arr[F(__is_move_constructible(volatile NoDefaultMoveAssignDueToDtor))]; }
+  { int arr[F(__is_move_constructible(const volatile NoDefaultMoveAssignDueToDtor))]; }
+  { int arr[T(__is_move_constructible(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int arr[T(__is_move_constructible(const NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int arr[F(__is_move_constructible(volatile NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int arr[F(__is_move_constructible(const volatile NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int arr[T(__is_move_constructible(NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int arr[T(__is_move_constructible(const NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int arr[F(__is_move_constructible(volatile NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int arr[F(__is_move_constructible(const volatile NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int arr[T(__is_move_constructible(NonTCStruct))]; }
+  { int arr[T(__is_move_constructible(const NonTCStruct))]; }
+  { int arr[F(__is_move_constructible(volatile NonTCStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile NonTCStruct))]; }
+  { int arr[T(__is_move_constructible(NonTrivialStruct))]; }
+  { int arr[T(__is_move_constructible(const NonTrivialStruct))]; }
+  { int arr[F(__is_move_constructible(volatile NonTrivialStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile NonTrivialStruct))]; }
+  { int arr[T(__is_move_constructible(POD))]; }
+  { int arr[T(__is_move_constructible(const POD))]; }
+  { int arr[F(__is_move_constructible(volatile POD))]; }
+  { int arr[F(__is_move_constructible(const volatile POD))]; }
+  { int arr[T(__is_move_constructible(SuperNonTrivialStruct))]; }
+  { int arr[T(__is_move_constructible(const SuperNonTrivialStruct))]; }
+  { int arr[F(__is_move_constructible(volatile SuperNonTrivialStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile SuperNonTrivialStruct))]; }
+  { int arr[T(__is_move_constructible(TrivialStruct))]; }
+  { int arr[T(__is_move_constructible(const TrivialStruct))]; }
+  { int arr[F(__is_move_constructible(volatile TrivialStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile TrivialStruct))]; }
+  { int arr[T(__is_move_constructible(Union))]; }
+  { int arr[T(__is_move_constructible(const Union))]; }
+  { int arr[F(__is_move_constructible(volatile Union))]; }
+  { int arr[F(__is_move_constructible(const volatile Union))]; }
+  { int arr[T(__is_move_constructible(VolatileMoveCtor))]; }
+  { int arr[F(__is_move_constructible(const VolatileMoveCtor))]; }
+  { int arr[T(__is_move_constructible(volatile VolatileMoveCtor))]; }
+  { int arr[F(__is_move_constructible(const volatile VolatileMoveCtor))]; }
+
+  { int arr[F(__is_move_constructible(AllDeleted))]; }
+  { int arr[F(__is_move_constructible(AllPrivate))]; }
+  { int arr[F(__is_move_constructible(AnIncompleteType[]))]; }
+  { int arr[F(__is_move_constructible(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_move_constructible(BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_move_constructible(BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_move_constructible(BaseDeletedMoveCtor))]; }
+  { int arr[F(__is_move_constructible(CopyCtorDeleted))]; }
+  { int arr[F(__is_move_constructible(CopyCtorDeleted))]; }
+  { int arr[F(__is_move_constructible(CVCopyCtor))]; }
+  { int arr[F(__is_move_constructible(HasMutableCopyCtor))]; }
+  { int arr[F(__is_move_constructible(HasMoveAssign))]; }
+  { int arr[F(__is_move_constructible(MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_move_constructible(MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_move_constructible(MemberDeletedMoveCtor))]; }
+  { int arr[F(__is_move_constructible(MoveCtorDeleted))]; }
+  { int arr[F(__is_move_constructible(VirtAr))]; }
+  { int arr[F(__is_move_constructible(VolatileCopyCtor))]; }
+
+  // Non-referencable types
+  { int arr[F(__is_move_constructible(void))]; }
+  { int arr[F(__is_move_constructible(void()))]; }
+}
+
+struct MutableCopyAssign_QualNone {
+  MutableCopyAssign_QualNone &operator=(MutableCopyAssign_QualNone &);
+};
+struct MutableCopyAssign_QualConst {
+  MutableCopyAssign_QualConst &operator=(MutableCopyAssign_QualConst &) const;
+};
+struct MutableCopyAssign_QualVolatile {
+  MutableCopyAssign_QualVolatile &operator=(MutableCopyAssign_QualVolatile &) volatile;
+};
+struct MutableCopyAssign_QualCV {
+  MutableCopyAssign_QualCV &operator=(MutableCopyAssign_QualCV &) const volatile;
+};
+struct MutableCopyAssign_QualLvalue {
+  MutableCopyAssign_QualLvalue &operator=(MutableCopyAssign_QualLvalue &) &;
+};
+struct MutableCopyAssign_QualConstLvalue {
+  MutableCopyAssign_QualConstLvalue &operator=(MutableCopyAssign_QualConstLvalue &) const &;
+};
+struct MutableCopyAssign_QualVolatileLvalue {
+  MutableCopyAssign_QualVolatileLvalue &operator=(MutableCopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct MutableCopyAssign_QualCVLvalue {
+  MutableCopyAssign_QualCVLvalue &operator=(MutableCopyAssign_QualCVLvalue &) const volatile &;
+};
+struct MutableCopyAssign_QualRvalue {
+  MutableCopyAssign_QualRvalue &operator=(MutableCopyAssign_QualRvalue &) &&;
+};
+struct MutableCopyAssign_QualConstRvalue {
+  MutableCopyAssign_QualConstRvalue &operator=(MutableCopyAssign_QualConstRvalue &) const &&;
+};
+struct MutableCopyAssign_QualVolatileRvalue {
+  MutableCopyAssign_QualVolatileRvalue &operator=(MutableCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct MutableCopyAssign_QualCVRvalue {
+  MutableCopyAssign_QualCVRvalue &operator=(MutableCopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct CopyAssign_QualNone {
+  CopyAssign_QualNone &operator=(const CopyAssign_QualNone &);
+};
+struct CopyAssign_QualConst {
+  CopyAssign_QualConst &operator=(const CopyAssign_QualConst &) const;
+};
+struct CopyAssign_QualVolatile {
+  CopyAssign_QualVolatile &operator=(const CopyAssign_QualVolatile &) volatile;
+};
+struct CopyAssign_QualCV {
+  CopyAssign_QualCV &operator=(const CopyAssign_QualCV &) const volatile;
+};
+struct CopyAssign_QualLvalue {
+  CopyAssign_QualLvalue &operator=(const CopyAssign_QualLvalue &) &;
+};
+struct CopyAssign_QualConstLvalue {
+  CopyAssign_QualConstLvalue &operator=(const CopyAssign_QualConstLvalue &) const &;
+};
+struct CopyAssign_QualVolatileLvalue {
+  CopyAssign_QualVolatileLvalue &operator=(const CopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct CopyAssign_QualCVLvalue {
+  CopyAssign_QualCVLvalue &operator=(const CopyAssign_QualCVLvalue &) const volatile &;
+};
+struct CopyAssign_QualRvalue {
+  CopyAssign_QualRvalue &operator=(const CopyAssign_QualRvalue &) &&;
+};
+struct CopyAssign_QualConstRvalue {
+  CopyAssign_QualConstRvalue &operator=(const CopyAssign_QualConstRvalue &) const &&;
+};
+struct CopyAssign_QualVolatileRvalue {
+  CopyAssign_QualVolatileRvalue &operator=(const CopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct CopyAssign_QualCVRvalue {
+  CopyAssign_QualCVRvalue &operator=(const CopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct VolatileCopyAssign_QualNone {
+  VolatileCopyAssign_QualNone &operator=(volatile VolatileCopyAssign_QualNone &);
+};
+struct VolatileCopyAssign_QualConst {
+  VolatileCopyAssign_QualConst &operator=(volatile VolatileCopyAssign_QualConst &) const;
+};
+struct VolatileCopyAssign_QualVolatile {
+  VolatileCopyAssign_QualVolatile &operator=(volatile VolatileCopyAssign_QualVolatile &) volatile;
+};
+struct VolatileCopyAssign_QualCV {
+  VolatileCopyAssign_QualCV &operator=(volatile VolatileCopyAssign_QualCV &) const volatile;
+};
+struct VolatileCopyAssign_QualLvalue {
+  VolatileCopyAssign_QualLvalue &operator=(volatile VolatileCopyAssign_QualLvalue &) &;
+};
+struct VolatileCopyAssign_QualConstLvalue {
+  VolatileCopyAssign_QualConstLvalue &operator=(volatile VolatileCopyAssign_QualConstLvalue &) const &;
+};
+struct VolatileCopyAssign_QualVolatileLvalue {
+  VolatileCopyAssign_QualVolatileLvalue &operator=(volatile VolatileCopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct VolatileCopyAssign_QualCVLvalue {
+  VolatileCopyAssign_QualCVLvalue &operator=(volatile VolatileCopyAssign_QualCVLvalue &) const volatile &;
+};
+struct VolatileCopyAssign_QualRvalue {
+  VolatileCopyAssign_QualRvalue &operator=(volatile VolatileCopyAssign_QualRvalue &) &&;
+};
+struct VolatileCopyAssign_QualConstRvalue {
+  VolatileCopyAssign_QualConstRvalue &operator=(volatile VolatileCopyAssign_QualConstRvalue &) const &&;
+};
+struct VolatileCopyAssign_QualVolatileRvalue {
+  VolatileCopyAssign_QualVolatileRvalue &operator=(volatile VolatileCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct VolatileCopyAssign_QualCVRvalue {
+  VolatileCopyAssign_QualCVRvalue &operator=(volatile VolatileCopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct CVCopyAssign_QualNone {
+  CVCopyAssign_QualNone &operator=(const volatile CVCopyAssign_QualNone &);
+};
+struct CVCopyAssign_QualConst {
+  CVCopyAssign_QualConst &operator=(const volatile CVCopyAssign_QualConst &) const;
+};
+struct CVCopyAssign_QualVolatile {
+  CVCopyAssign_QualVolatile &operator=(const volatile CVCopyAssign_QualVolatile &) volatile;
+};
+struct CVCopyAssign_QualCV {
+  CVCopyAssign_QualCV &operator=(const volatile CVCopyAssign_QualCV &) const volatile;
+};
+struct CVCopyAssign_QualLvalue {
+  CVCopyAssign_QualLvalue &operator=(const volatile CVCopyAssign_QualLvalue &) &;
+};
+struct CVCopyAssign_QualConstLvalue {
+  CVCopyAssign_QualConstLvalue &operator=(const volatile CVCopyAssign_QualConstLvalue &) const &;
+};
+struct CVCopyAssign_QualCVLvalue {
+  CVCopyAssign_QualCVLvalue &operator=(const volatile CVCopyAssign_QualCVLvalue &) volatile &;
+};
+struct CVCopyAssign_QualVolatileLvalue {
+  CVCopyAssign_QualVolatileLvalue &operator=(const volatile CVCopyAssign_QualVolatileLvalue &) const volatile &;
+};
+struct CVCopyAssign_QualRvalue {
+  CVCopyAssign_QualRvalue &operator=(const volatile CVCopyAssign_QualRvalue &) &&;
+};
+struct CVCopyAssign_QualConstRvalue {
+  CVCopyAssign_QualConstRvalue &operator=(const volatile CVCopyAssign_QualConstRvalue &) const &&;
+};
+struct CVCopyAssign_QualVolatileRvalue {
+  CVCopyAssign_QualVolatileRvalue &operator=(const volatile CVCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct CVCopyAssign_QualCVRvalue {
+  CVCopyAssign_QualCVRvalue &operator=(const volatile CVCopyAssign_QualCVRvalue &) const volatile &&;
+};
+struct CopyAssignDeleted {
+  CopyAssignDeleted &operator=(const CopyAssignDeleted &) = delete;
+};
+struct BaseDeletedCopyAssign : CopyAssignDeleted {};
+struct HasMemberWithDeletedCopyAssign {
+  CopyAssignDeleted x;
+};
+
+void copy_assignable_checks() {
+  // Builtin types
+  { int a[T(__is_copy_assignable(int))]; }
+  { int a[T(__is_copy_assignable(int &))]; }
+  { int a[T(__is_copy_assignable(int &&))]; }
+  { int a[T(__is_copy_assignable(int *))]; }
+  { int a[F(__is_copy_assignable(int[5]))]; }
+  { int a[F(__is_copy_assignable(int[]))]; }
+  { int a[T(__is_copy_assignable(decltype(nullptr)))]; }
+  { int a[T(__is_copy_assignable(void (*)()))]; }
+  { int a[F(__is_copy_assignable(void (&)()))]; }
+  { int a[T(__is_copy_assignable(int Empty::*))]; }
+  { int a[T(__is_copy_assignable(int (Empty::*)()))]; }
+
+  // // User-defined types
+  { int a[T(__is_copy_assignable(AllDefaulted))]; }
+  { int a[T(__is_copy_assignable(AllDefaulted))]; }
+  { int a[T(__is_copy_assignable(BaseDeletedCopyCtor))]; }
+  { int a[T(__is_copy_assignable(CEmptyStruct))]; }
+  { int a[T(__is_copy_assignable(CopyCtorDeleted))]; }
+  { int a[T(__is_copy_assignable(CppEmptyStruct))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardBy2ndVirtBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByMemb))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByProt))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardBySameBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByVirt))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByVirtBase))]; }
+  { int a[T(__is_copy_assignable(CppStructStandard))]; }
+  { int a[T(__is_copy_assignable(CStruct))]; }
+  { int a[T(__is_copy_assignable(CVCopyCtor))]; }
+  { int a[T(__is_copy_assignable(Derives))]; }
+  { int a[T(__is_copy_assignable(DerivesHasCopyAssign))]; }
+  { int a[T(__is_copy_assignable(Empty))]; }
+  { int a[T(__is_copy_assignable(EmptyUnion))]; }
+  { int a[T(__is_copy_assignable(Enum))]; }
+  { int a[T(__is_copy_assignable(EnumClass))]; }
+  { int a[T(__is_copy_assignable(ExtDefaulted))]; }
+  { int a[T(__is_copy_assignable(ExtDefaulted))]; }
+  { int a[T(__is_copy_assignable(HasCons))]; }
+  { int a[T(__is_copy_assignable(HasCopyAssign))]; }
+  { int a[T(__is_copy_assignable(HasDest))]; }
+  { int a[T(__is_copy_assignable(HasMutableCopyCtor))]; }
+  { int a[T(__is_copy_assignable(HasPriv))]; }
+  { int a[T(__is_copy_assignable(HasMultipleCopyAssign))]; }
+  { int a[T(__is_copy_assignable(HasTemplateCons))]; }
+  { int a[T(__is_copy_assignable(MemberDeletedCopyCtor))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToDtor))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int a[T(__is_copy_assignable(NonTCStruct))]; }
+  { int a[T(__is_copy_assignable(NonTrivialStruct))]; }
+  { int a[T(__is_copy_assignable(POD))]; }
+  { int a[T(__is_copy_assignable(SuperNonTrivialStruct))]; }
+  { int a[T(__is_copy_assignable(TrivialStruct))]; }
+  { int a[T(__is_copy_assignable(Union))]; }
+
+  { int a[F(__is_copy_assignable(AllDeleted))]; }
+  { int a[F(__is_copy_assignable(AllPrivate))]; }
+  { int a[F(__is_copy_assignable(AnIncompleteType[]))]; }
+  { int a[F(__is_copy_assignable(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int a[F(__is_copy_assignable(DerivesHasRef))]; }
+  { int a[F(__is_copy_assignable(HasRef))]; }
+  { int a[F(__is_copy_assignable(HasMove))]; }
+  { int a[F(__is_copy_assignable(HasMoveAssign))]; }
+  { int a[F(__is_copy_assignable(VirtAr))]; }
+  { int a[F(__is_copy_assignable(CopyAssignDeleted))]; }
+  { int a[F(__is_copy_assignable(BaseDeletedCopyAssign))]; }
+  { int a[F(__is_copy_assignable(HasMemberWithDeletedCopyAssign))]; }
+
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualNone))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConstLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCVRvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualNone))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualConstLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualVolatileLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualCVRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualNone))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConstLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCVRvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualNone))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualConstLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualVolatileLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualCVRvalue))]; }
+
+  // Non-referencable types
+  { int a[F(__is_copy_assignable(void))]; }
+  { int a[F(__is_copy_assignable(void()))]; }
+
+  // cv-qualified types
+  { int a[F(__is_copy_assignable(const int))]; }
+  { int a[F(__is_copy_assignable(const Empty))]; }
+  { int a[T(__is_copy_assignable(volatile int))]; }
+  { int a[F(__is_copy_assignable(volatile Empty))]; }
+  { int a[F(__is_copy_assignable(const volatile int))]; }
+  { int a[F(__is_copy_assignable(const volatile Empty))]; }
+
+  { int a[T(__is_copy_assignable(const CopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(volatile CopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(const volatile CopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(const VolatileCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(volatile VolatileCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(const volatile VolatileCopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(const CVCopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(volatile CVCopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(const volatile CVCopyAssign_QualCV))]; }
+}
+
+struct MoveAssign_QualNone {
+  MoveAssign_QualNone &operator=(MoveAssign_QualNone &&);
+};
+struct MoveAssign_QualConst {
+  MoveAssign_QualConst &operator=(MoveAssign_QualConst &&) const;
+};
+struct MoveAssign_QualVolatile {
+  MoveAssign_QualVolatile &operator=(MoveAssign_QualVolatile &&) volatile;
+};
+struct MoveAssign_QualCV {
+  MoveAssign_QualCV &operator=(MoveAssign_QualCV &&) const volatile;
+};
+struct MoveAssign_QualLvalue {
+  MoveAssign_QualLvalue &operator=(MoveAssign_QualLvalue &&) &;
+};
+struct MoveAssign_QualConstLvalue {
+  MoveAssign_QualConstLvalue &operator=(MoveAssign_QualConstLvalue &&) const &;
+};
+struct MoveAssign_QualVolatileLvalue {
+  MoveAssign_QualVolatileLvalue &operator=(MoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct MoveAssign_QualCVLvalue {
+  MoveAssign_QualCVLvalue &operator=(MoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct MoveAssign_QualRvalue {
+  MoveAssign_QualRvalue &operator=(MoveAssign_QualRvalue &&) &&;
+};
+struct MoveAssign_QualConstRvalue {
+  MoveAssign_QualConstRvalue &operator=(MoveAssign_QualConstRvalue &&) const &&;
+};
+struct MoveAssign_QualVolatileRvalue {
+  MoveAssign_QualVolatileRvalue &operator=(MoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct MoveAssign_QualCVRvalue {
+  MoveAssign_QualCVRvalue &operator=(MoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct ConstMoveAssign_QualNone {
+  ConstMoveAssign_QualNone &operator=(const ConstMoveAssign_QualNone &&);
+};
+struct ConstMoveAssign_QualConst {
+  ConstMoveAssign_QualConst &operator=(const ConstMoveAssign_QualConst &&) const;
+};
+struct ConstMoveAssign_QualVolatile {
+  ConstMoveAssign_QualVolatile &operator=(const ConstMoveAssign_QualVolatile &&) volatile;
+};
+struct ConstMoveAssign_QualCV {
+  ConstMoveAssign_QualCV &operator=(const ConstMoveAssign_QualCV &&) const volatile;
+};
+struct ConstMoveAssign_QualLvalue {
+  ConstMoveAssign_QualLvalue &operator=(const ConstMoveAssign_QualLvalue &&) &;
+};
+struct ConstMoveAssign_QualConstLvalue {
+  ConstMoveAssign_QualConstLvalue &operator=(const ConstMoveAssign_QualConstLvalue &&) const &;
+};
+struct ConstMoveAssign_QualVolatileLvalue {
+  ConstMoveAssign_QualVolatileLvalue &operator=(const ConstMoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct ConstMoveAssign_QualCVLvalue {
+  ConstMoveAssign_QualCVLvalue &operator=(const ConstMoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct ConstMoveAssign_QualRvalue {
+  ConstMoveAssign_QualRvalue &operator=(const ConstMoveAssign_QualRvalue &&) &&;
+};
+struct ConstMoveAssign_QualConstRvalue {
+  ConstMoveAssign_QualConstRvalue &operator=(const ConstMoveAssign_QualConstRvalue &&) const &&;
+};
+struct ConstMoveAssign_QualVolatileRvalue {
+  ConstMoveAssign_QualVolatileRvalue &operator=(const ConstMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct ConstMoveAssign_QualCVRvalue {
+  ConstMoveAssign_QualCVRvalue &operator=(const ConstMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct VolatileMoveAssign_QualNone {
+  VolatileMoveAssign_QualNone &operator=(volatile VolatileMoveAssign_QualNone &&);
+};
+struct VolatileMoveAssign_QualConst {
+  VolatileMoveAssign_QualConst &operator=(volatile VolatileMoveAssign_QualConst &&) const;
+};
+struct VolatileMoveAssign_QualVolatile {
+  VolatileMoveAssign_QualVolatile &operator=(volatile VolatileMoveAssign_QualVolatile &&) volatile;
+};
+struct VolatileMoveAssign_QualCV {
+  VolatileMoveAssign_QualCV &operator=(volatile VolatileMoveAssign_QualCV &&) const volatile;
+};
+struct VolatileMoveAssign_QualLvalue {
+  VolatileMoveAssign_QualLvalue &operator=(volatile VolatileMoveAssign_QualLvalue &&) &;
+};
+struct VolatileMoveAssign_QualConstLvalue {
+  VolatileMoveAssign_QualConstLvalue &operator=(volatile VolatileMoveAssign_QualConstLvalue &&) const &;
+};
+struct VolatileMoveAssign_QualVolatileLvalue {
+  VolatileMoveAssign_QualVolatileLvalue &operator=(volatile VolatileMoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct VolatileMoveAssign_QualCVLvalue {
+  VolatileMoveAssign_QualCVLvalue &operator=(volatile VolatileMoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct VolatileMoveAssign_QualRvalue {
+  VolatileMoveAssign_QualRvalue &operator=(volatile VolatileMoveAssign_QualRvalue &&) &&;
+};
+struct VolatileMoveAssign_QualConstRvalue {
+  VolatileMoveAssign_QualConstRvalue &operator=(volatile VolatileMoveAssign_QualConstRvalue &&) const &&;
+};
+struct VolatileMoveAssign_QualVolatileRvalue {
+  VolatileMoveAssign_QualVolatileRvalue &operator=(volatile VolatileMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct VolatileMoveAssign_QualCVRvalue {
+  VolatileMoveAssign_QualCVRvalue &operator=(volatile VolatileMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct CVMoveAssign_QualNone {
+  CVMoveAssign_QualNone &operator=(const volatile CVMoveAssign_QualNone &&);
+};
+struct CVMoveAssign_QualConst {
+  CVMoveAssign_QualConst &operator=(const volatile CVMoveAssign_QualConst &&) const;
+};
+struct CVMoveAssign_QualVolatile {
+  CVMoveAssign_QualVolatile &operator=(const volatile CVMoveAssign_QualVolatile &&) volatile;
+};
+struct CVMoveAssign_QualCV {
+  CVMoveAssign_QualCV &operator=(const volatile CVMoveAssign_QualCV &&) const volatile;
+};
+struct CVMoveAssign_QualLvalue {
+  CVMoveAssign_QualLvalue &operator=(const volatile CVMoveAssign_QualLvalue &&) &;
+};
+struct CVMoveAssign_QualConstLvalue {
+  CVMoveAssign_QualConstLvalue &operator=(const volatile CVMoveAssign_QualConstLvalue &&) const &;
+};
+struct CVMoveAssign_QualCVLvalue {
+  CVMoveAssign_QualCVLvalue &operator=(const volatile CVMoveAssign_QualCVLvalue &&) volatile &;
+};
+struct CVMoveAssign_QualVolatileLvalue {
+  CVMoveAssign_QualVolatileLvalue &operator=(const volatile CVMoveAssign_QualVolatileLvalue &&) const volatile &;
+};
+struct CVMoveAssign_QualRvalue {
+  CVMoveAssign_QualRvalue &operator=(const volatile CVMoveAssign_QualRvalue &&) &&;
+};
+struct CVMoveAssign_QualConstRvalue {
+  CVMoveAssign_QualConstRvalue &operator=(const volatile CVMoveAssign_QualConstRvalue &&) const &&;
+};
+struct CVMoveAssign_QualVolatileRvalue {
+  CVMoveAssign_QualVolatileRvalue &operator=(const volatile CVMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct CVMoveAssign_QualCVRvalue {
+  CVMoveAssign_QualCVRvalue &operator=(const volatile CVMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+struct MoveAssignDeleted {
+  MoveAssignDeleted &operator=(const MoveAssignDeleted &&) = delete;
+};
+struct BaseDeletedMoveAssign : MoveAssignDeleted {};
+struct HasMemberWithDeletedMoveAssign {
+  MoveAssignDeleted x;
+};
+
+void move_assignable_checks() {
+  // Builtin types
+  { int a[T(__is_move_assignable(int))]; }
+  { int a[T(__is_move_assignable(int &))]; }
+  { int a[T(__is_move_assignable(int &&))]; }
+  { int a[T(__is_move_assignable(int *))]; }
+  { int a[F(__is_move_assignable(int[5]))]; }
+  { int a[F(__is_move_assignable(int[]))]; }
+  { int a[T(__is_move_assignable(decltype(nullptr)))]; }
+  { int a[T(__is_move_assignable(void (*)()))]; }
+  { int a[F(__is_move_assignable(void (&)()))]; }
+  { int a[T(__is_move_assignable(int Empty::*))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)()))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile &&))]; }
+
+  // // User-defined types
+  { int a[T(__is_move_assignable(AllDefaulted))]; }
+  { int a[T(__is_move_assignable(AllDefaulted))]; }
+  { int a[T(__is_move_assignable(BaseDeletedCopyCtor))]; }
+  { int a[T(__is_move_assignable(CEmptyStruct))]; }
+  { int a[T(__is_move_assignable(CopyCtorDeleted))]; }
+  { int a[T(__is_move_assignable(CppEmptyStruct))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardBy2ndVirtBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByMemb))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByProt))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardBySameBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByVirt))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByVirtBase))]; }
+  { int a[T(__is_move_assignable(CppStructStandard))]; }
+  { int a[T(__is_move_assignable(CStruct))]; }
+  { int a[T(__is_move_assignable(CVCopyCtor))]; }
+  { int a[T(__is_move_assignable(Derives))]; }
+  { int a[T(__is_move_assignable(DerivesHasCopyAssign))]; }
+  { int a[T(__is_move_assignable(Empty))]; }
+  { int a[T(__is_move_assignable(EmptyUnion))]; }
+  { int a[T(__is_move_assignable(Enum))]; }
+  { int a[T(__is_move_assignable(EnumClass))]; }
+  { int a[T(__is_move_assignable(ExtDefaulted))]; }
+  { int a[T(__is_move_assignable(ExtDefaulted))]; }
+  { int a[T(__is_move_assignable(HasCons))]; }
+  { int a[T(__is_move_assignable(HasCopyAssign))]; }
+  { int a[T(__is_move_assignable(HasDest))]; }
+  { int a[T(__is_move_assignable(HasMutableCopyCtor))]; }
+  { int a[T(__is_move_assignable(HasPriv))]; }
+  { int a[T(__is_move_assignable(HasMultipleCopyAssign))]; }
+  { int a[T(__is_move_assignable(HasTemplateCons))]; }
+  { int a[T(__is_move_assignable(MemberDeletedCopyCtor))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToDtor))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int a[T(__is_move_assignable(NonTCStruct))]; }
+  { int a[T(__is_move_assignable(NonTrivialStruct))]; }
+  { int a[T(__is_move_assignable(POD))]; }
+  { int a[T(__is_move_assignable(SuperNonTrivialStruct))]; }
+  { int a[T(__is_move_assignable(TrivialStruct))]; }
+  { int a[T(__is_move_assignable(Union))]; }
+  { int a[T(__is_move_assignable(HasMoveAssign))]; }
+
+  { int a[F(__is_move_assignable(AllDeleted))]; }
+  { int a[F(__is_move_assignable(AllPrivate))]; }
+  { int a[F(__is_move_assignable(AnIncompleteType[]))]; }
+  { int a[F(__is_move_assignable(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int a[F(__is_move_assignable(DerivesHasRef))]; }
+  { int a[F(__is_move_assignable(HasRef))]; }
+  { int a[F(__is_move_assignable(HasMove))]; }
+  { int a[F(__is_move_assignable(VirtAr))]; }
+  { int a[F(__is_move_assignable(MoveAssignDeleted))]; }
+  { int a[F(__is_move_assignable(BaseDeletedMoveAssign))]; }
+  { int a[F(__is_move_assignable(HasMemberWithDeletedMoveAssign))]; }
+
+  { int a[T(__is_move_assignable(MoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(MoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(ConstMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(ConstMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(VolatileMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(VolatileMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(CVMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(CVMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCVRvalue))]; }
+
+  // Non-referencable types
+  { int a[F(__is_move_assignable(void))]; }
+  { int a[F(__is_move_assignable(void()))]; }
+
+  // cv-qualified types
+  { int a[F(__is_move_assignable(const int))]; }
+  { int a[F(__is_move_assignable(const Empty))]; }
+  { int a[T(__is_move_assignable(volatile int))]; }
+  { int a[F(__is_move_assignable(volatile Empty))]; }
+  { int a[F(__is_move_assignable(const volatile int))]; }
+  { int a[F(__is_move_assignable(const volatile Empty))]; }
+
+  { int a[F(__is_move_assignable(const MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(volatile MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(const volatile MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(volatile MoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(const volatile MoveAssign_QualCV))]; }
+  { int a[F(__is_move_assignable(const VolatileMoveAssign_QualConst))]; }
+  { int a[T(__is_move_assignable(volatile VolatileMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(const volatile VolatileMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(const CVMoveAssign_QualConst))]; }
+  { int a[T(__is_move_assignable(volatile CVMoveAssign_QualVolatile))]; }
+  { int a[T(__is_move_assignable(const volatile CVMoveAssign_QualCV))]; }
+}
+
 // Instantiation of __is_trivially_constructible
 template<typename T, typename ...Args>
 struct is_trivially_constructible {
@@ -2401,6 +3699,92 @@
   { int arr[T((__reference_binds_to_temporary(const int &, long)))]; }
 }
 
+void reference_constructs_from_temporary_checks() {
+  { int arr[F((__reference_constructs_from_temporary(int &, int &)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int &, int &&)))]; }
+
+  { int arr[F((__reference_constructs_from_temporary(int const &, int &)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int const &, int const &)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int const &, int &&)))]; }
+
+  { int arr[F((__reference_constructs_from_temporary(int &, long &)))]; } // doesn't construct
+
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_constructs_from_temporary(int const &, long &)))]; }
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_constructs_from_temporary(int const &, long &&)))]; }
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_constructs_from_temporary(int &&, long &)))]; }
+
+  using LRef = ConvertsToRef<int, int &>;
+  using RRef = ConvertsToRef<int, int &&>;
+  using CLRef = ConvertsToRef<int, const int &>;
+  using LongRef = ConvertsToRef<long, long &>;
+  { int arr[T((__is_constructible(int &, LRef)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int &, LRef)))]; }
+
+  { int arr[T((__is_constructible(int &&, RRef)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int &&, RRef)))]; }
+
+  { int arr[T((__is_constructible(int const &, CLRef)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int &&, CLRef)))]; }
+
+  { int arr[T((__is_constructible(int const &, LongRef)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int const &, LongRef)))]; }
+
+  // Test that it doesn't accept non-reference types as input.
+  { int arr[F((__reference_constructs_from_temporary(int, long)))]; }
+
+  { int arr[F((__reference_constructs_from_temporary(const int &, long)))]; }
+
+  // Additional checks
+  { int arr[T((__reference_constructs_from_temporary(int&&, int)))]; }
+  { int arr[T((__reference_constructs_from_temporary(POD const&, Derives)))]; }
+}
+
+void reference_converts_from_temporary_checks() {
+  { int arr[F((__reference_converts_from_temporary(int &, int &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int &, int &&)))]; }
+
+  { int arr[F((__reference_converts_from_temporary(int const &, int &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int const &, int const &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int const &, int &&)))]; }
+
+  { int arr[F((__reference_converts_from_temporary(int &, long &)))]; } // doesn't construct
+
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_converts_from_temporary(int const &, long &)))]; }
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_converts_from_temporary(int const &, long &&)))]; }
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_converts_from_temporary(int &&, long &)))]; }
+
+  using LRef = ConvertsToRef<int, int &>;
+  using RRef = ConvertsToRef<int, int &&>;
+  using CLRef = ConvertsToRef<int, const int &>;
+  using LongRef = ConvertsToRef<long, long &>;
+  { int arr[T((__is_convertible(LRef, int &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int &, LRef)))]; }
+
+  { int arr[T((__is_convertible(RRef, int &&)))]; }
+  { int arr[F((__reference_converts_from_temporary(int &&, RRef)))]; }
+
+  { int arr[T((__is_convertible(CLRef, int const &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int &&, CLRef)))]; }
+
+  { int arr[T((__is_convertible(LongRef, int const &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int const &, LongRef)))]; }
+
+  // Test that it doesn't accept non-reference types as input.
+  { int arr[F((__reference_converts_from_temporary(int, long)))]; }
+
+  { int arr[F((__reference_converts_from_temporary(const int &, long)))]; }
+
+  // Additional checks
+  { int arr[T((__reference_converts_from_temporary(int&&, int)))]; }
+  { int arr[T((__reference_converts_from_temporary(POD const&, Derives)))]; }
+}
+
 void array_rank() {
   int t01[T(__array_rank(IntAr) == 1)];
   int t02[T(__array_rank(ConstIntArAr) == 2)];
@@ -3295,6 +4679,8 @@
     static_assert(__is_same(remove_cvref_t<M>, M), "");
     static_assert(__is_same(remove_pointer_t<M>, M), "");
     static_assert(__is_same(remove_reference_t<M>, M), "");
+
+    static_assert(!__is_referenceable(M), "");
   }
 };
 
Index: clang/test/SemaCXX/deprecated-builtins.cpp
===================================================================
--- clang/test/SemaCXX/deprecated-builtins.cpp
+++ clang/test/SemaCXX/deprecated-builtins.cpp
@@ -5,15 +5,15 @@
 void f() {
     bool a;
 
-    a = __has_nothrow_assign(A);  // expected-warning-re {{__has_nothrow_assign {{.*}} use __is_nothrow_assignable}}
-    a = __has_nothrow_move_assign(A);  // expected-warning-re {{__has_nothrow_move_assign {{.*}} use __is_nothrow_assignable}}
-    a = __has_nothrow_copy(A);  // expected-warning-re {{__has_nothrow_copy {{.*}} use __is_nothrow_constructible}}
+    a = __has_nothrow_assign(A);  // expected-warning-re {{__has_nothrow_assign {{.*}} use __is_nothrow_copy_assignable}}
+    a = __has_nothrow_move_assign(A);  // expected-warning-re {{__has_nothrow_move_assign {{.*}} use __is_nothrow_move_assignable}}
+    a = __has_nothrow_copy(A);  // expected-warning-re {{__has_nothrow_copy {{.*}} use __is_nothrow_copy_constructible}}
     a = __has_nothrow_constructor(A);  // expected-warning-re {{__has_nothrow_constructor {{.*}} use __is_nothrow_constructible}}
     a = __has_trivial_assign(A);  // expected-warning-re {{__has_trivial_assign {{.*}} use __is_trivially_assignable}}
-    a = __has_trivial_move_assign(A);  // expected-warning-re {{__has_trivial_move_assign {{.*}} use __is_trivially_assignable}}
-    a = __has_trivial_copy(A);  // expected-warning-re {{__has_trivial_copy {{.*}} use __is_trivially_copyable}}
+    a = __has_trivial_move_assign(A);  // expected-warning-re {{__has_trivial_move_assign {{.*}} use __is_trivially_move_assignable}}
+    a = __has_trivial_copy(A);  // expected-warning-re {{__has_trivial_copy {{.*}} use __is_trivially_copy_copyable}}
     a = __has_trivial_constructor(A);  // expected-warning-re {{__has_trivial_constructor {{.*}} use __is_trivially_constructible}}
-    a = __has_trivial_move_constructor(A);  // expected-warning-re {{__has_trivial_move_constructor {{.*}} use __is_trivially_constructible}}
+    a = __has_trivial_move_constructor(A);  // expected-warning-re {{__has_trivial_move_constructor {{.*}} use __is_trivially_move_constructible}}
     a = __has_trivial_destructor(A);  // expected-warning-re {{__has_trivial_destructor {{.*}} use __is_trivially_destructible}}
 
 }
Index: clang/lib/Sema/SemaType.cpp
===================================================================
--- clang/lib/Sema/SemaType.cpp
+++ clang/lib/Sema/SemaType.cpp
@@ -2627,12 +2627,10 @@
 
   if (T->isVariableArrayType() && !Context.getTargetInfo().isVLASupported()) {
     // CUDA device code and some other targets don't support VLAs.
-    targetDiag(Loc, (getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
-                        ? diag::err_cuda_vla
-                        : diag::err_vla_unsupported)
-        << ((getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
-                ? CurrentCUDATarget()
-                : CFT_InvalidTarget);
+    bool IsCUDADevice = (getLangOpts().CUDA && getLangOpts().CUDAIsDevice);
+    targetDiag(Loc,
+               IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported)
+        << (IsCUDADevice ? CurrentCUDATarget() : 0);
   }
 
   // If this is not C99, diagnose array size modifiers on non-VLAs.
Index: clang/lib/Sema/SemaExprCXX.cpp
===================================================================
--- clang/lib/Sema/SemaExprCXX.cpp
+++ clang/lib/Sema/SemaExprCXX.cpp
@@ -21,12 +21,14 @@
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/AlignedAllocation.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TypeTraits.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
@@ -4756,12 +4758,16 @@
   case UTT_IsIntegral:
   case UTT_IsFloatingPoint:
   case UTT_IsArray:
+  case UTT_IsBoundedArray:
   case UTT_IsPointer:
+  case UTT_IsNullPointer:
+  case UTT_IsReferenceable:
   case UTT_IsLvalueReference:
   case UTT_IsRvalueReference:
   case UTT_IsMemberFunctionPointer:
   case UTT_IsMemberObjectPointer:
   case UTT_IsEnum:
+  case UTT_IsScopedEnum:
   case UTT_IsUnion:
   case UTT_IsClass:
   case UTT_IsFunction:
@@ -4782,6 +4788,7 @@
   case UTT_IsConst:
   case UTT_IsVolatile:
   case UTT_IsSigned:
+  case UTT_IsUnboundedArray:
   case UTT_IsUnsigned:
 
   // This type trait always returns false, checking the type is moot.
@@ -4841,6 +4848,18 @@
   case UTT_IsNothrowDestructible:
   case UTT_IsTriviallyDestructible:
   case UTT_HasUniqueObjectRepresentations:
+  case UTT_IsCopyConstructible:
+  case UTT_IsTriviallyCopyConstructible:
+  case UTT_IsNothrowCopyConstructible:
+  case UTT_IsCopyAssignable:
+  case UTT_IsTriviallyCopyAssignable:
+  case UTT_IsNothrowCopyAssignable:
+  case UTT_IsMoveConstructible:
+  case UTT_IsTriviallyMoveConstructible:
+  case UTT_IsNothrowMoveConstructible:
+  case UTT_IsMoveAssignable:
+  case UTT_IsTriviallyMoveAssignable:
+  case UTT_IsNothrowMoveAssignable:
     if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
       return true;
 
@@ -4884,6 +4903,12 @@
   return false;
 }
 
+static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
+                              ArrayRef<TypeSourceInfo *> Args,
+                              SourceLocation RParenLoc);
+static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
+                                    QualType RhsT, SourceLocation KeyLoc);
+
 static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
                                    SourceLocation KeyLoc, QualType T) {
   assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
@@ -4901,8 +4926,20 @@
     return T->isFloatingType();
   case UTT_IsArray:
     return T->isArrayType();
+  case UTT_IsBoundedArray:
+    if (T->isVariableArrayType())
+      Self.Diag(KeyLoc, diag::err_vla_unsupported)
+          << 1 << tok::kw___is_bounded_array;
+    return T->isArrayType() && !T->isIncompleteArrayType();
+  case UTT_IsUnboundedArray:
+    if (T->isVariableArrayType())
+      Self.Diag(KeyLoc, diag::err_vla_unsupported)
+          << 1 << tok::kw___is_unbounded_array;
+    return T->isIncompleteArrayType();
   case UTT_IsPointer:
     return T->isAnyPointerType();
+  case UTT_IsNullPointer:
+    return T->isNullPtrType();
   case UTT_IsLvalueReference:
     return T->isLValueReferenceType();
   case UTT_IsRvalueReference:
@@ -4913,6 +4950,8 @@
     return T->isMemberDataPointerType();
   case UTT_IsEnum:
     return T->isEnumeralType();
+  case UTT_IsScopedEnum:
+    return T->isScopedEnumeralType();
   case UTT_IsUnion:
     return T->isUnionType();
   case UTT_IsClass:
@@ -5284,26 +5323,78 @@
     return C.hasUniqueObjectRepresentations(T);
   case UTT_IsTriviallyRelocatable:
     return T.isTriviallyRelocatableType(C);
+  case UTT_IsCopyConstructible:
+  case UTT_IsTriviallyCopyConstructible:
+  case UTT_IsNothrowCopyConstructible:
+  case UTT_IsCopyAssignable:
+  case UTT_IsTriviallyCopyAssignable:
+  case UTT_IsNothrowCopyAssignable: {
+    if (T->isIncompleteArrayType())
+      return false;
+    if (!T.isReferenceable())
+      return false;
+
+    QualType AssigneeType = T;
+    AssigneeType.addConst();
+    AssigneeType = Self.BuiltinAddReference(AssigneeType, UnaryTransformType::AddLvalueReference, KeyLoc);
+    if (UTT == UTT_IsCopyAssignable || UTT == UTT_IsTriviallyCopyAssignable || UTT == UTT_IsNothrowCopyAssignable) {
+      return EvaluateBinaryTypeTrait(
+          Self,
+          UTT == UTT_IsCopyAssignable          ? BTT_IsAssignable
+        : UTT == UTT_IsTriviallyCopyAssignable ? BTT_IsTriviallyAssignable
+                                               : BTT_IsNothrowAssignable,
+          Self.BuildReferenceType(T, true, KeyLoc, T.getBaseTypeIdentifier()),
+          AssigneeType, KeyLoc);
+    }
+    llvm::SmallVector<TypeSourceInfo *, 2> Parameters = {
+        C.CreateTypeSourceInfo(T), C.CreateTypeSourceInfo(AssigneeType)};
+    return evaluateTypeTrait(Self, UTT == UTT_IsCopyConstructible ? TT_IsConstructible :
+                                   UTT == UTT_IsTriviallyCopyConstructible ? TT_IsTriviallyConstructible
+                                                                           : TT_IsNothrowConstructible, KeyLoc, Parameters, {});
+  }
+  case UTT_IsMoveConstructible:
+  case UTT_IsTriviallyMoveConstructible:
+  case UTT_IsNothrowMoveConstructible:
+  case UTT_IsMoveAssignable:
+  case UTT_IsTriviallyMoveAssignable:
+  case UTT_IsNothrowMoveAssignable: {
+    if (T->isIncompleteArrayType())
+      return false;
+    if (!T.isReferenceable())
+      return false;
+
+    QualType AssigneeType = Self.BuiltinAddReference(T, UnaryTransformType::AddRvalueReference, KeyLoc);
+    if (UTT == UTT_IsMoveAssignable || UTT == UTT_IsTriviallyMoveAssignable || UTT == UTT_IsNothrowMoveAssignable)
+      return EvaluateBinaryTypeTrait(
+          Self,
+          UTT == UTT_IsMoveAssignable ? BTT_IsAssignable
+        : UTT == UTT_IsTriviallyMoveAssignable ? BTT_IsTriviallyAssignable : BTT_IsNothrowAssignable,
+          Self.BuildReferenceType(T, true, KeyLoc, T.getBaseTypeIdentifier()),
+          AssigneeType, KeyLoc);
+    llvm::SmallVector<TypeSourceInfo *, 2> Parameters = {
+        C.CreateTypeSourceInfo(T), C.CreateTypeSourceInfo(AssigneeType)};
+    return evaluateTypeTrait(Self, UTT == UTT_IsMoveConstructible ? TT_IsConstructible : UTT == UTT_IsTriviallyMoveConstructible ? TT_IsTriviallyConstructible : TT_IsNothrowConstructible, KeyLoc, Parameters, {});
+  }
+  case UTT_IsReferenceable:
+    return T.isReferenceable();
   }
 }
 
-static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
-                                    QualType RhsT, SourceLocation KeyLoc);
-
 static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
                               ArrayRef<TypeSourceInfo *> Args,
                               SourceLocation RParenLoc) {
   if (Kind <= UTT_Last)
     return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
 
-  // Evaluate BTT_ReferenceBindsToTemporary alongside the IsConstructible
-  // traits to avoid duplication.
-  if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary)
+  // Evaluate ReferenceBindsToTemporary and ReferenceConstructsFromTemporary
+  // alongside the IsConstructible traits to avoid duplication.
+  if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary && Kind != BTT_ReferenceConstructsFromTemporary)
     return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(),
                                    Args[1]->getType(), RParenLoc);
 
   switch (Kind) {
   case clang::BTT_ReferenceBindsToTemporary:
+  case clang::BTT_ReferenceConstructsFromTemporary:
   case clang::TT_IsConstructible:
   case clang::TT_IsNothrowConstructible:
   case clang::TT_IsTriviallyConstructible: {
@@ -5387,6 +5478,16 @@
       return !Init.isDirectReferenceBinding();
     }
 
+    if (Kind == clang::BTT_ReferenceConstructsFromTemporary) {
+      QualType U = Args[1]->getType();
+      if (!T->isReferenceType() || U->isReferenceType())
+        return false;
+
+      QualType TPtr = S.BuiltinAddPointer(S.BuiltinRemoveReference(T, UnaryTransformType::RemoveCVRef, {}), {});
+      QualType UPtr = S.BuiltinAddPointer(S.BuiltinRemoveReference(U, UnaryTransformType::RemoveCVRef, {}), {});
+      return EvaluateBinaryTypeTrait(S, TypeTrait::BTT_IsConvertibleTo, UPtr, TPtr, RParenLoc) && Init.isDirectReferenceBinding();
+    }
+
     if (Kind == clang::TT_IsNothrowConstructible)
       return S.canThrow(Result.get()) == CT_Cannot;
 
@@ -5416,24 +5517,32 @@
   TypeTrait Replacement;
   switch (Kind) {
     case UTT_HasNothrowAssign:
+      Replacement = UTT_IsNothrowCopyAssignable;
+      break;
     case UTT_HasNothrowMoveAssign:
-      Replacement = BTT_IsNothrowAssignable;
+      Replacement = UTT_IsNothrowMoveAssignable;
       break;
-    case UTT_HasNothrowCopy:
     case UTT_HasNothrowConstructor:
       Replacement = TT_IsNothrowConstructible;
       break;
+    case UTT_HasNothrowCopy:
+      Replacement = UTT_IsNothrowCopyConstructible;
+      break;
     case UTT_HasTrivialAssign:
-    case UTT_HasTrivialMoveAssign:
       Replacement = BTT_IsTriviallyAssignable;
       break;
+    case UTT_HasTrivialMoveAssign:
+      Replacement = UTT_IsTriviallyMoveAssignable;
+      break;
     case UTT_HasTrivialCopy:
       Replacement = UTT_IsTriviallyCopyable;
       break;
     case UTT_HasTrivialDefaultConstructor:
-    case UTT_HasTrivialMoveConstructor:
       Replacement = TT_IsTriviallyConstructible;
       break;
+    case UTT_HasTrivialMoveConstructor:
+      Replacement = UTT_IsTriviallyMoveConstructible;
+      break;
     case UTT_HasTrivialDestructor:
       Replacement = UTT_IsTriviallyDestructible;
       break;
@@ -5573,7 +5682,8 @@
     return Self.Context.typesAreCompatible(Lhs, Rhs);
   }
   case BTT_IsConvertible:
-  case BTT_IsConvertibleTo: {
+  case BTT_IsConvertibleTo:
+  case BTT_ReferenceConvertsFromTemporary: {
     // C++0x [meta.rel]p4:
     //   Given the following function prototype:
     //
@@ -5612,8 +5722,14 @@
       return false;
 
     // Compute the result of add_rvalue_reference.
-    if (LhsT->isObjectType() || LhsT->isFunctionType())
+    bool RvalueReferenceAdded = false;
+    if (LhsT->isObjectType() || LhsT->isFunctionType()) {
+      RvalueReferenceAdded = true;
       LhsT = Self.Context.getRValueReferenceType(LhsT);
+    }
+
+    if (BTT == BTT_ReferenceConvertsFromTemporary)
+      std::swap(LhsT, RhsT);
 
     // Build a fake source and destination for initialization.
     InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT));
@@ -5634,7 +5750,18 @@
       return false;
 
     ExprResult Result = Init.Perform(Self, To, Kind, FromPtr);
-    return !Result.isInvalid() && !SFINAE.hasErrorOccurred();
+    if (Result.isInvalid() || SFINAE.hasErrorOccurred())
+      return false;
+
+    if (BTT != clang::BTT_ReferenceConvertsFromTemporary) return true;
+
+    // They're swapped, so we need to consider LhsT and RhsT back-to-front.
+    if (RvalueReferenceAdded || LhsT->isReferenceType())
+      return false;
+
+    QualType UPtr = Self.BuiltinAddPointer(Self.BuiltinRemoveReference(LhsT, UnaryTransformType::RemoveCVRef, {}), {});
+    QualType TPtr = Self.BuiltinAddPointer(Self.BuiltinRemoveReference(RhsT, UnaryTransformType::RemoveCVRef, {}), {});
+    return EvaluateBinaryTypeTrait(Self, TypeTrait::BTT_IsConvertibleTo, UPtr, TPtr, KeyLoc) and Kind.isCopyInit();
   }
 
   case BTT_IsAssignable:
Index: clang/lib/Parse/ParseExpr.cpp
===================================================================
--- clang/lib/Parse/ParseExpr.cpp
+++ clang/lib/Parse/ParseExpr.cpp
@@ -1067,6 +1067,7 @@
           REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
           REVERTIBLE_TYPE_TRAIT(__is_array);
           REVERTIBLE_TYPE_TRAIT(__is_assignable);
+          REVERTIBLE_TYPE_TRAIT(__is_bounded_array);
           REVERTIBLE_TYPE_TRAIT(__is_base_of);
           REVERTIBLE_TYPE_TRAIT(__is_class);
           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
@@ -1102,6 +1103,7 @@
           REVERTIBLE_TYPE_TRAIT(__is_rvalue_reference);
           REVERTIBLE_TYPE_TRAIT(__is_same);
           REVERTIBLE_TYPE_TRAIT(__is_scalar);
+          REVERTIBLE_TYPE_TRAIT(__is_scoped_enum);
           REVERTIBLE_TYPE_TRAIT(__is_sealed);
           REVERTIBLE_TYPE_TRAIT(__is_signed);
           REVERTIBLE_TYPE_TRAIT(__is_standard_layout);
@@ -1109,6 +1111,7 @@
           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_copyable);
+          REVERTIBLE_TYPE_TRAIT(__is_unbounded_array);
           REVERTIBLE_TYPE_TRAIT(__is_union);
           REVERTIBLE_TYPE_TRAIT(__is_unsigned);
           REVERTIBLE_TYPE_TRAIT(__is_void);
Index: clang/lib/Parse/ParseDeclCXX.cpp
===================================================================
--- clang/lib/Parse/ParseDeclCXX.cpp
+++ clang/lib/Parse/ParseDeclCXX.cpp
@@ -1578,12 +1578,17 @@
           tok::kw___is_arithmetic,
           tok::kw___is_array,
           tok::kw___is_assignable,
+          tok::kw___is_copy_assignable,
+          tok::kw___is_move_assignable,
           tok::kw___is_base_of,
+          tok::kw___is_bounded_array,
           tok::kw___is_class,
           tok::kw___is_complete_type,
           tok::kw___is_compound,
           tok::kw___is_const,
           tok::kw___is_constructible,
+          tok::kw___is_copy_constructible,
+          tok::kw___is_move_constructible,
           tok::kw___is_convertible,
           tok::kw___is_convertible_to,
           tok::kw___is_destructible,
@@ -1602,17 +1607,24 @@
           tok::kw___is_member_object_pointer,
           tok::kw___is_member_pointer,
           tok::kw___is_nothrow_assignable,
+          tok::kw___is_nothrow_copy_assignable,
+          tok::kw___is_nothrow_move_assignable,
           tok::kw___is_nothrow_constructible,
+          tok::kw___is_nothrow_copy_constructible,
+          tok::kw___is_nothrow_move_constructible,
           tok::kw___is_nothrow_destructible,
+          tok::kw___is_nullptr,
           tok::kw___is_object,
           tok::kw___is_pod,
           tok::kw___is_pointer,
           tok::kw___is_polymorphic,
           tok::kw___is_reference,
+          tok::kw___is_referenceable,
           tok::kw___is_rvalue_expr,
           tok::kw___is_rvalue_reference,
           tok::kw___is_same,
           tok::kw___is_scalar,
+          tok::kw___is_scoped_enum,
           tok::kw___is_sealed,
           tok::kw___is_signed,
           tok::kw___is_standard_layout,
@@ -1620,6 +1632,7 @@
           tok::kw___is_trivially_assignable,
           tok::kw___is_trivially_constructible,
           tok::kw___is_trivially_copyable,
+          tok::kw___is_unbounded_array,
           tok::kw___is_union,
           tok::kw___is_unsigned,
           tok::kw___is_void,
Index: clang/lib/Lex/PPMacroExpansion.cpp
===================================================================
--- clang/lib/Lex/PPMacroExpansion.cpp
+++ clang/lib/Lex/PPMacroExpansion.cpp
@@ -1700,6 +1700,8 @@
               .Case("__array_rank", true)
               .Case("__array_extent", true)
               .Case("__reference_binds_to_temporary", true)
+              .Case("__reference_constructs_from_temporary", true)
+              .Case("__reference_converts_from_temporary", true)
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) .Case("__" #Trait, true)
 #include "clang/Basic/TransformTypeTraits.def"
               .Default(false);
Index: clang/include/clang/Basic/TokenKinds.def
===================================================================
--- clang/include/clang/Basic/TokenKinds.def
+++ clang/include/clang/Basic/TokenKinds.def
@@ -466,12 +466,24 @@
 TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS)
 
 // MSVC12.0 / VS2013 Type Traits
-TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYMS)
+TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_destructible, IsTriviallyDestructible, KEYCXX)
-TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYMS)
+TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYCXX)
 TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX)
 TYPE_TRAIT_N(__is_constructible, IsConstructible, KEYCXX)
 TYPE_TRAIT_N(__is_nothrow_constructible, IsNothrowConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_copy_constructible, IsCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_copy_constructible, IsNothrowCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_copy_assignable, IsCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_copy_assignable, IsNothrowCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_move_constructible, IsMoveConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_move_constructible, IsNothrowMoveConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_move_assignable, IsMoveAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_move_assignable, IsNothrowMoveAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_copy_constructible, IsTriviallyCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_copy_assignable, IsTriviallyCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_move_constructible, IsTriviallyMoveConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_move_assignable, IsTriviallyMoveAssignable, KEYCXX)
 
 // MSVC14.0 / VS2015 Type Traits
 TYPE_TRAIT_2(__is_assignable, IsAssignable, KEYCXX)
@@ -518,7 +530,14 @@
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
+TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
+TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)
+TYPE_TRAIT_1(__is_nullptr, IsNullPointer, KEYCXX)
+TYPE_TRAIT_1(__is_scoped_enum, IsScopedEnum, KEYCXX)
+TYPE_TRAIT_1(__is_referenceable, IsReferenceable, KEYCXX)
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
+TYPE_TRAIT_2(__reference_constructs_from_temporary, ReferenceConstructsFromTemporary, KEYCXX)
+TYPE_TRAIT_2(__reference_converts_from_temporary, ReferenceConvertsFromTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
Index: clang/include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -147,7 +147,7 @@
   "variable length array folded to constant array as an extension">,
   InGroup<GNUFoldingConstant>;
 def err_vla_unsupported : Error<
-  "variable length arrays are not supported for the current target">;
+  "variable length arrays are not supported for %select{the current target|'%1'}0">;
 def note_vla_unsupported : Note<
   "variable length arrays are not supported for the current target">;
 

_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits