[clang] adds copy-assignable type-trait builtins

[cjdb]

Summary

• __is_copy_assignable
• __is_nothrow_copy_assignable
• __is_trivially_copy_assignable

This is information that the compiler already has, and should be exposed
so that the library doesn't need to reimplement the exact same
functionality.

Similarly to __is_copy_construcitble, etc., these traits can't be
implemented using __is_assignable, etc., because we can't form
references to void, and references are a fundamental part of copy
assignment.

Depends on D135238.

[cjdb]

corrects commit message

[erichkeane]

Same comment as the previous patch on triviality.

[cjdb]

Abandoning, since this doesn't have consensus.

clang/include/clang/Basic/TokenKinds.def

 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_1(__is_copy_constructible, IsCopyConstructible, KEYCXX)
 TYPE_TRAIT_1(__is_nothrow_copy_constructible, IsNothrowCopyConstructible, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_copy_constructible, IsTriviallyCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_copy_assignable, IsCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_copy_assignable, IsNothrowCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_copy_assignable, IsTriviallyCopyAssignable, KEYCXX)
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
 
 // Embarcadero Unary Type Traits
 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)

clang/lib/Parse/ParseDeclCXX.cpp

#include "clang/Basic/TransformTypeTraits.def"
           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_copy_assignable,
           tok::kw___is_convertible,
           tok::kw___is_convertible_to,
           tok::kw___is_destructible,
           tok::kw___is_empty,
           tok::kw___is_enum,
           tok::kw___is_floating_point,
           tok::kw___is_final,
           tok::kw___is_function,
           tok::kw___is_fundamental,
           tok::kw___is_integral,
           tok::kw___is_interface_class,
           tok::kw___is_literal,
           tok::kw___is_lvalue_expr,
           tok::kw___is_lvalue_reference,
           tok::kw___is_member_function_pointer,
           tok::kw___is_member_object_pointer,
           tok::kw___is_member_pointer,
           tok::kw___is_nothrow_assignable,
           tok::kw___is_nothrow_constructible,
+          tok::kw___is_nothrow_copy_assignable,
           tok::kw___is_nothrow_copy_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,
           tok::kw___is_trivial,
           tok::kw___is_trivially_assignable,
           tok::kw___is_trivially_constructible,
+          tok::kw___is_trivially_copy_assignable,
           tok::kw___is_trivially_copy_constructible,
           tok::kw___is_trivially_copyable,
           tok::kw___is_unbounded_array,
           tok::kw___is_union,
           tok::kw___is_unsigned,
           tok::kw___is_void,
           tok::kw___is_volatile))
     // GNU libstdc++ 4.2 and libc++ use certain intrinsic names as the

clang/lib/Parse/ParseExpr.cpp

#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           REVERTIBLE_TYPE_TRAIT(__is_bounded_array);
           REVERTIBLE_TYPE_TRAIT(__is_class);
           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
           REVERTIBLE_TYPE_TRAIT(__is_compound);
           REVERTIBLE_TYPE_TRAIT(__is_const);
           REVERTIBLE_TYPE_TRAIT(__is_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_convertible_to);
           REVERTIBLE_TYPE_TRAIT(__is_convertible);
+          REVERTIBLE_TYPE_TRAIT(__is_copy_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_copy_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_destructible);
           REVERTIBLE_TYPE_TRAIT(__is_empty);
           REVERTIBLE_TYPE_TRAIT(__is_enum);
           REVERTIBLE_TYPE_TRAIT(__is_final);
           REVERTIBLE_TYPE_TRAIT(__is_floating_point);
           REVERTIBLE_TYPE_TRAIT(__is_function);
           REVERTIBLE_TYPE_TRAIT(__is_fundamental);
           REVERTIBLE_TYPE_TRAIT(__is_integral);
           REVERTIBLE_TYPE_TRAIT(__is_interface_class);
           REVERTIBLE_TYPE_TRAIT(__is_literal);
           REVERTIBLE_TYPE_TRAIT(__is_lvalue_expr);
           REVERTIBLE_TYPE_TRAIT(__is_lvalue_reference);
           REVERTIBLE_TYPE_TRAIT(__is_member_function_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_member_object_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_member_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_constructible);
+          REVERTIBLE_TYPE_TRAIT(__is_nothrow_copy_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_copy_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_destructible);
           REVERTIBLE_TYPE_TRAIT(__is_nullptr);
           REVERTIBLE_TYPE_TRAIT(__is_object);
           REVERTIBLE_TYPE_TRAIT(__is_pod);
           REVERTIBLE_TYPE_TRAIT(__is_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_polymorphic);
           REVERTIBLE_TYPE_TRAIT(__is_reference);
           REVERTIBLE_TYPE_TRAIT(__is_referenceable);
           REVERTIBLE_TYPE_TRAIT(__is_rvalue_expr);
           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);
           REVERTIBLE_TYPE_TRAIT(__is_trivial);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
+          REVERTIBLE_TYPE_TRAIT(__is_trivially_copy_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_copy_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);
           REVERTIBLE_TYPE_TRAIT(__is_volatile);
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait)                                     \

clang/lib/Sema/SemaExprCXX.cpp

static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   //   T shall be a complete type, cv void, or an array of unknown bound.
   case UTT_IsDestructible:
   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:
     if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
       return true;
 
     return !S.RequireCompleteType(
         Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
   }
 }
 
case UTT_IsCompleteType:
     //   function call.
     return !T->isIncompleteType();
   case UTT_HasUniqueObjectRepresentations:
     return C.hasUniqueObjectRepresentations(T);
   case UTT_IsTriviallyRelocatable:
     return T.isTriviallyRelocatableType(C);
   case UTT_IsCopyConstructible:
   case UTT_IsTriviallyCopyConstructible:
-  case UTT_IsNothrowCopyConstructible: {
+  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, {});
static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
   return false;
 }
 
 namespace {
 void DiagnoseBuiltinDeprecation(Sema& S, TypeTrait Kind,
                                 SourceLocation KWLoc) {
   TypeTrait Replacement;
   switch (Kind) {
-    case UTT_HasNothrowAssign:
-    case UTT_HasNothrowMoveAssign:
-      Replacement = BTT_IsNothrowAssignable;
-      break;
-    case UTT_HasNothrowCopy:
-      Replacement = UTT_IsNothrowCopyConstructible;
-      break;
-    case UTT_HasNothrowConstructor:
-      Replacement = TT_IsNothrowConstructible;
-      break;
-    case UTT_HasTrivialAssign:
-    case UTT_HasTrivialMoveAssign:
-      Replacement = BTT_IsTriviallyAssignable;
-      break;
-    case UTT_HasTrivialCopy:
-      Replacement = UTT_IsTriviallyCopyConstructible;
-      break;
-    case UTT_HasTrivialDefaultConstructor:
-    case UTT_HasTrivialMoveConstructor:
-      Replacement = TT_IsTriviallyConstructible;
-      break;
-    case UTT_HasTrivialDestructor:
-      Replacement = UTT_IsTriviallyDestructible;
-      break;
-    default:
-      return;
+  case UTT_HasNothrowAssign: // despite its name, this checks copy assignment
+    Replacement = UTT_IsNothrowCopyAssignable;
+    break;
+  case UTT_HasTrivialAssign: // despite its name, this checks copy assignment
+    Replacement = UTT_IsTriviallyCopyAssignable;
+    break;
   }
   S.Diag(KWLoc, diag::warn_deprecated_builtin)
     << getTraitSpelling(Kind) << getTraitSpelling(Replacement);
 }
 }
 
 bool Sema::CheckTypeTraitArity(unsigned Arity, SourceLocation Loc, size_t N) {
   if (Arity && N != Arity) {

clang/test/SemaCXX/deprecated-builtins.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct A {};
 
 void f() {
     bool a;
 
-    a = __has_nothrow_assign(A);  // expected-warning-re {{__has_nothrow_assign {{.*}} use __is_nothrow_assignable}}
+    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_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_assign(A);  // expected-warning-re {{__has_trivial_assign {{.*}} use __is_trivially_copy_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_copy_constructible}}
     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_destructor(A);  // expected-warning-re {{__has_trivial_destructor {{.*}} use __is_trivially_destructible}}
 
 }

clang/test/SemaCXX/type-traits.cpp

void copy_constructible_checks() {
   static_assert(!__is_nothrow_copy_constructible(void), "");
   static_assert(!__is_trivially_copy_constructible(void), "");
 
   static_assert(!__is_copy_constructible(void()), "");
   static_assert(!__is_nothrow_copy_constructible(void()), "");
   static_assert(!__is_trivially_copy_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
+  static_assert(__is_copy_assignable(int), "");
+  static_assert(__is_nothrow_copy_assignable(int), "");
+  static_assert(__is_trivially_copy_assignable(int), "");
+
+  static_assert(__is_copy_assignable(int &), "");
+  static_assert(__is_nothrow_copy_assignable(int &), "");
+  static_assert(__is_trivially_copy_assignable(int &), "");
+
+  static_assert(__is_copy_assignable(int &&), "");
+  static_assert(__is_nothrow_copy_assignable(int &&), "");
+  static_assert(__is_trivially_copy_assignable(int &&), "");
+
+  static_assert(__is_copy_assignable(int *), "");
+  static_assert(__is_nothrow_copy_assignable(int *), "");
+  static_assert(__is_trivially_copy_assignable(int *), "");
+
+  static_assert(!__is_copy_assignable(int[5]), "");
+  static_assert(!__is_nothrow_copy_assignable(int[5]), "");
+  static_assert(!__is_trivially_copy_assignable(int[5]), "");
+
+  static_assert(!__is_copy_assignable(int[]), "");
+  static_assert(!__is_nothrow_copy_assignable(int[]), "");
+  static_assert(!__is_trivially_copy_assignable(int[]), "");
+
+  static_assert(__is_copy_assignable(decltype(nullptr)), "");
+  static_assert(__is_nothrow_copy_assignable(decltype(nullptr)), "");
+  static_assert(__is_trivially_copy_assignable(decltype(nullptr)), "");
+
+  static_assert(__is_copy_assignable(void (*)()), "");
+  static_assert(__is_nothrow_copy_assignable(void (*)()), "");
+  static_assert(__is_trivially_copy_assignable(void (*)()), "");
+
+  static_assert(!__is_copy_assignable(void (&)()), "");
+  static_assert(!__is_nothrow_copy_assignable(void (&)()), "");
+  static_assert(!__is_trivially_copy_assignable(void (&)()), "");
+
+  static_assert(__is_copy_assignable(int Empty::*), "");
+  static_assert(__is_nothrow_copy_assignable(int Empty::*), "");
+  static_assert(__is_trivially_copy_assignable(int Empty::*), "");
+
+  static_assert(__is_copy_assignable(int (Empty::*)()), "");
+  static_assert(__is_nothrow_copy_assignable(int (Empty::*)()), "");
+  static_assert(__is_trivially_copy_assignable(int (Empty::*)()), "");
+
+  // // User-defined types
+  static_assert(__is_copy_assignable(AllDefaulted), "");
+  static_assert(__is_nothrow_copy_assignable(AllDefaulted), "");
+  static_assert(__is_trivially_copy_assignable(AllDefaulted), "");
+
+  static_assert(__is_copy_assignable(BaseDeletedCopyCtor), "");
+  static_assert(__is_nothrow_copy_assignable(BaseDeletedCopyCtor), "");
+  static_assert(__is_trivially_copy_assignable(BaseDeletedCopyCtor), "");
+
+  static_assert(__is_copy_assignable(CEmptyStruct), "");
+  static_assert(__is_nothrow_copy_assignable(CEmptyStruct), "");
+  static_assert(__is_trivially_copy_assignable(CEmptyStruct), "");
+
+  static_assert(__is_copy_assignable(CopyCtorDeleted), "");
+  static_assert(__is_nothrow_copy_assignable(CopyCtorDeleted), "");
+  static_assert(__is_trivially_copy_assignable(CopyCtorDeleted), "");
+
+  static_assert(__is_copy_assignable(CppEmptyStruct), "");
+  static_assert(__is_nothrow_copy_assignable(CppEmptyStruct), "");
+  static_assert(__is_trivially_copy_assignable(CppEmptyStruct), "");
+
+  static_assert(__is_copy_assignable(CppStructNonStandardBy2ndVirtBase), "");
+  static_assert(__is_nothrow_copy_assignable(CppStructNonStandardBy2ndVirtBase), "");
+  static_assert(__is_trivially_copy_assignable(CppStructNonStandardBy2ndVirtBase), "");
+
+  static_assert(__is_copy_assignable(CppStructNonStandardByBase), "");
+  static_assert(__is_nothrow_copy_assignable(CppStructNonStandardByBase), "");
+  static_assert(__is_trivially_copy_assignable(CppStructNonStandardByBase), "");
+
+  static_assert(__is_copy_assignable(CppStructNonStandardByMemb), "");
+  static_assert(__is_nothrow_copy_assignable(CppStructNonStandardByMemb), "");
+  static_assert(!__is_trivially_copy_assignable(CppStructNonStandardByMemb), "");
+
+  static_assert(__is_copy_assignable(CppStructNonStandardByProt), "");
+  static_assert(__is_nothrow_copy_assignable(CppStructNonStandardByProt), "");
+  static_assert(__is_trivially_copy_assignable(CppStructNonStandardByProt), "");
+
+  static_assert(__is_copy_assignable(CppStructNonStandardBySameBase), "");
+  static_assert(__is_nothrow_copy_assignable(CppStructNonStandardBySameBase), "");
+  static_assert(__is_trivially_copy_assignable(CppStructNonStandardBySameBase), "");
+
+  static_assert(__is_copy_assignable(CppStructNonStandardByVirt), "");
+  static_assert(__is_nothrow_copy_assignable(CppStructNonStandardByVirt), "");
+  static_assert(!__is_trivially_copy_assignable(CppStructNonStandardByVirt), "");
+
+  static_assert(__is_copy_assignable(CppStructNonStandardByVirtBase), "");
+  static_assert(__is_nothrow_copy_assignable(CppStructNonStandardByVirtBase), "");
+  static_assert(!__is_trivially_copy_assignable(CppStructNonStandardByVirtBase), "");
+
+  static_assert(__is_copy_assignable(CppStructStandard), "");
+  static_assert(__is_nothrow_copy_assignable(CppStructStandard), "");
+  static_assert(__is_trivially_copy_assignable(CppStructStandard), "");
+
+  static_assert(__is_copy_assignable(CStruct), "");
+  static_assert(__is_nothrow_copy_assignable(CStruct), "");
+  static_assert(__is_trivially_copy_assignable(CStruct), "");
+
+  static_assert(__is_copy_assignable(CVCopyCtor), "");
+  static_assert(__is_nothrow_copy_assignable(CVCopyCtor), "");
+  static_assert(__is_trivially_copy_assignable(CVCopyCtor), "");
+
+  static_assert(__is_copy_assignable(Derives), "");
+  static_assert(__is_nothrow_copy_assignable(Derives), "");
+  static_assert(__is_trivially_copy_assignable(Derives), "");
+
+  static_assert(__is_copy_assignable(DerivesHasCopyAssign), "");
+  static_assert(!__is_nothrow_copy_assignable(DerivesHasCopyAssign), "");
+  static_assert(!__is_trivially_copy_assignable(DerivesHasCopyAssign), "");
+
+  static_assert(__is_copy_assignable(Empty), "");
+  static_assert(__is_nothrow_copy_assignable(Empty), "");
+  static_assert(__is_trivially_copy_assignable(Empty), "");
+
+  static_assert(__is_copy_assignable(EmptyUnion), "");
+  static_assert(__is_nothrow_copy_assignable(EmptyUnion), "");
+  static_assert(__is_trivially_copy_assignable(EmptyUnion), "");
+
+  static_assert(__is_copy_assignable(Enum), "");
+  static_assert(__is_nothrow_copy_assignable(Enum), "");
+  static_assert(__is_trivially_copy_assignable(Enum), "");
+
+  static_assert(__is_copy_assignable(EnumClass), "");
+  static_assert(__is_nothrow_copy_assignable(EnumClass), "");
+  static_assert(__is_trivially_copy_assignable(EnumClass), "");
+
+  static_assert(__is_copy_assignable(ExtDefaulted), "");
+  static_assert(!__is_nothrow_copy_assignable(ExtDefaulted), "");
+  static_assert(!__is_trivially_copy_assignable(ExtDefaulted), "");
+
+  static_assert(__is_copy_assignable(HasCons), "");
+  static_assert(__is_nothrow_copy_assignable(HasCons), "");
+  static_assert(__is_trivially_copy_assignable(HasCons), "");
+
+  static_assert(__is_copy_assignable(HasCopyAssign), "");
+  static_assert(!__is_nothrow_copy_assignable(HasCopyAssign), "");
+  static_assert(!__is_trivially_copy_assignable(HasCopyAssign), "");
+
+  static_assert(__is_copy_assignable(HasDest), "");
+  static_assert(__is_nothrow_copy_assignable(HasDest), "");
+  static_assert(__is_trivially_copy_assignable(HasDest), "");
+
+  static_assert(__is_copy_assignable(HasMutableCopyCtor), "");
+  static_assert(__is_nothrow_copy_assignable(HasMutableCopyCtor), "");
+  static_assert(__is_trivially_copy_assignable(HasMutableCopyCtor), "");
+
+  static_assert(__is_copy_assignable(HasPriv), "");
+  static_assert(__is_nothrow_copy_assignable(HasPriv), "");
+  static_assert(__is_trivially_copy_assignable(HasPriv), "");
+
+  static_assert(__is_copy_assignable(HasMultipleCopyAssign), "");
+  static_assert(__is_nothrow_copy_assignable(HasMultipleCopyAssign), "");
+  static_assert(!__is_trivially_copy_assignable(HasMultipleCopyAssign), "");
+
+  static_assert(__is_copy_assignable(HasTemplateCons), "");
+  static_assert(__is_nothrow_copy_assignable(HasTemplateCons), "");
+  static_assert(!__is_trivially_copy_assignable(HasTemplateCons), "");
+
+  static_assert(__is_copy_assignable(MemberDeletedCopyCtor), "");
+  static_assert(__is_nothrow_copy_assignable(MemberDeletedCopyCtor), "");
+  static_assert(__is_trivially_copy_assignable(MemberDeletedCopyCtor), "");
+
+  static_assert(__is_copy_assignable(NoDefaultMoveAssignDueToDtor), "");
+  static_assert(__is_nothrow_copy_assignable(NoDefaultMoveAssignDueToDtor), "");
+  static_assert(__is_trivially_copy_assignable(NoDefaultMoveAssignDueToDtor), "");
+
+  static_assert(__is_copy_assignable(NoDefaultMoveAssignDueToUDCopyAssign), "");
+  static_assert(!__is_nothrow_copy_assignable(NoDefaultMoveAssignDueToUDCopyAssign), "");
+  static_assert(!__is_trivially_copy_assignable(NoDefaultMoveAssignDueToUDCopyAssign), "");
+
+  static_assert(__is_copy_assignable(NoDefaultMoveAssignDueToUDCopyCtor), "");
+  static_assert(__is_nothrow_copy_assignable(NoDefaultMoveAssignDueToUDCopyCtor), "");
+  static_assert(__is_trivially_copy_assignable(NoDefaultMoveAssignDueToUDCopyCtor), "");
+
+  static_assert(__is_copy_assignable(NonTCStruct), "");
+  static_assert(__is_nothrow_copy_assignable(NonTCStruct), "");
+  static_assert(__is_trivially_copy_assignable(NonTCStruct), "");
+
+  static_assert(__is_copy_assignable(NonTrivialStruct), "");
+  static_assert(__is_nothrow_copy_assignable(NonTrivialStruct), "");
+  static_assert(__is_trivially_copy_assignable(NonTrivialStruct), "");
+
+  static_assert(__is_copy_assignable(POD), "");
+  static_assert(__is_nothrow_copy_assignable(POD), "");
+  static_assert(__is_trivially_copy_assignable(POD), "");
+
+  static_assert(__is_copy_assignable(SuperNonTrivialStruct), "");
+  static_assert(__is_nothrow_copy_assignable(SuperNonTrivialStruct), "");
+  static_assert(__is_trivially_copy_assignable(SuperNonTrivialStruct), "");
+
+  static_assert(__is_copy_assignable(TrivialStruct), "");
+  static_assert(__is_nothrow_copy_assignable(TrivialStruct), "");
+  static_assert(__is_trivially_copy_assignable(TrivialStruct), "");
+
+  static_assert(__is_copy_assignable(Union), "");
+  static_assert(__is_nothrow_copy_assignable(Union), "");
+  static_assert(__is_trivially_copy_assignable(Union), "");
+
+  static_assert(!__is_copy_assignable(AllDeleted), "");
+  static_assert(!__is_nothrow_copy_assignable(AllDeleted), "");
+  static_assert(!__is_trivially_copy_assignable(AllDeleted), "");
+
+  static_assert(!__is_copy_assignable(AllPrivate), "");
+  static_assert(!__is_nothrow_copy_assignable(AllPrivate), "");
+  static_assert(!__is_trivially_copy_assignable(AllPrivate), "");
+
+  static_assert(!__is_copy_assignable(AnIncompleteType[]), "");
+  static_assert(!__is_nothrow_copy_assignable(AnIncompleteType[]), "");
+  static_assert(!__is_trivially_copy_assignable(AnIncompleteType[]), "");
+
+  static_assert(!__is_copy_assignable(AnIncompleteType), ""); // expected-error{{incomplete type}}
+  static_assert(!__is_nothrow_copy_assignable(AnIncompleteType), ""); // expected-error{{incomplete type}}
+  static_assert(!__is_trivially_copy_assignable(AnIncompleteType), ""); // expected-error{{incomplete type}}
+
+  static_assert(!__is_copy_assignable(DerivesHasRef), "");
+  static_assert(!__is_nothrow_copy_assignable(DerivesHasRef), "");
+  static_assert(!__is_trivially_copy_assignable(DerivesHasRef), "");
+
+  static_assert(!__is_copy_assignable(HasRef), "");
+  static_assert(!__is_nothrow_copy_assignable(HasRef), "");
+  static_assert(!__is_trivially_copy_assignable(HasRef), "");
+
+  static_assert(!__is_copy_assignable(HasMove), "");
+  static_assert(!__is_nothrow_copy_assignable(HasMove), "");
+  static_assert(!__is_trivially_copy_assignable(HasMove), "");
+
+  static_assert(!__is_copy_assignable(HasMoveAssign), "");
+  static_assert(!__is_nothrow_copy_assignable(HasMoveAssign), "");
+  static_assert(!__is_trivially_copy_assignable(HasMoveAssign), "");
+
+  static_assert(!__is_copy_assignable(VirtAr), "");
+  static_assert(!__is_nothrow_copy_assignable(VirtAr), "");
+  static_assert(!__is_trivially_copy_assignable(VirtAr), "");
+
+  static_assert(!__is_copy_assignable(CopyAssignDeleted), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssignDeleted), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssignDeleted), "");
+
+  static_assert(!__is_copy_assignable(BaseDeletedCopyAssign), "");
+  static_assert(!__is_nothrow_copy_assignable(BaseDeletedCopyAssign), "");
+  static_assert(!__is_trivially_copy_assignable(BaseDeletedCopyAssign), "");
+
+  static_assert(!__is_copy_assignable(HasMemberWithDeletedCopyAssign), "");
+  static_assert(!__is_nothrow_copy_assignable(HasMemberWithDeletedCopyAssign), "");
+  static_assert(!__is_trivially_copy_assignable(HasMemberWithDeletedCopyAssign), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualNone), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualNone), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualNone), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualConst), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualConst), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualConst), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualVolatile), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualVolatile), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualCV), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualCV), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualCV), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualLvalue), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualConstLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualConstLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualConstLvalue), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualVolatileLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualVolatileLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualVolatileLvalue), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualCVLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualCVLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualCVLvalue), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualRvalue), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualConstRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualConstRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualConstRvalue), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualVolatileRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualVolatileRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualVolatileRvalue), "");
+
+  static_assert(!__is_copy_assignable(MutableCopyAssign_QualCVRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(MutableCopyAssign_QualCVRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(MutableCopyAssign_QualCVRvalue), "");
+
+  static_assert(__is_copy_assignable(CopyAssign_QualNone), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualNone), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualNone), "");
+
+  static_assert(__is_copy_assignable(CopyAssign_QualConst), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualConst), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualConst), "");
+
+  static_assert(__is_copy_assignable(CopyAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualVolatile), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualVolatile), "");
+
+  static_assert(__is_copy_assignable(CopyAssign_QualCV), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualCV), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualCV), "");
+
+  static_assert(__is_copy_assignable(CopyAssign_QualLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualLvalue), "");
+
+  static_assert(__is_copy_assignable(CopyAssign_QualConstLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualConstLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualConstLvalue), "");
+
+  static_assert(__is_copy_assignable(CopyAssign_QualVolatileLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualVolatileLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualVolatileLvalue), "");
+
+  static_assert(__is_copy_assignable(CopyAssign_QualCVLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualCVLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualCVLvalue), "");
+
+  static_assert(!__is_copy_assignable(CopyAssign_QualRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualRvalue), "");
+
+  static_assert(!__is_copy_assignable(CopyAssign_QualConstRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualConstRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualConstRvalue), "");
+
+  static_assert(!__is_copy_assignable(CopyAssign_QualVolatileRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualVolatileRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualVolatileRvalue), "");
+
+  static_assert(!__is_copy_assignable(CopyAssign_QualCVRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CopyAssign_QualCVRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CopyAssign_QualCVRvalue), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualNone), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualNone), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualNone), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualConst), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualConst), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualConst), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualVolatile), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualVolatile), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualCV), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualCV), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualCV), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualLvalue), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualConstLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualConstLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualConstLvalue), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualVolatileLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualVolatileLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualVolatileLvalue), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualCVLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualCVLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualCVLvalue), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualRvalue), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualConstRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualConstRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualConstRvalue), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualVolatileRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualVolatileRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualVolatileRvalue), "");
+
+  static_assert(!__is_copy_assignable(VolatileCopyAssign_QualCVRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(VolatileCopyAssign_QualCVRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(VolatileCopyAssign_QualCVRvalue), "");
+
+  static_assert(__is_copy_assignable(CVCopyAssign_QualNone), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualNone), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualNone), "");
+
+  static_assert(__is_copy_assignable(CVCopyAssign_QualConst), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualConst), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualConst), "");
+
+  static_assert(__is_copy_assignable(CVCopyAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualVolatile), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualVolatile), "");
+
+  static_assert(__is_copy_assignable(CVCopyAssign_QualCV), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualCV), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualCV), "");
+
+  static_assert(__is_copy_assignable(CVCopyAssign_QualLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualLvalue), "");
+
+  static_assert(__is_copy_assignable(CVCopyAssign_QualConstLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualConstLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualConstLvalue), "");
+
+  static_assert(__is_copy_assignable(CVCopyAssign_QualVolatileLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualVolatileLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualVolatileLvalue), "");
+
+  static_assert(__is_copy_assignable(CVCopyAssign_QualCVLvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualCVLvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualCVLvalue), "");
+
+  static_assert(!__is_copy_assignable(CVCopyAssign_QualRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualRvalue), "");
+
+  static_assert(!__is_copy_assignable(CVCopyAssign_QualConstRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualConstRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualConstRvalue), "");
+
+  static_assert(!__is_copy_assignable(CVCopyAssign_QualVolatileRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualVolatileRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualVolatileRvalue), "");
+
+  static_assert(!__is_copy_assignable(CVCopyAssign_QualCVRvalue), "");
+  static_assert(!__is_nothrow_copy_assignable(CVCopyAssign_QualCVRvalue), "");
+  static_assert(!__is_trivially_copy_assignable(CVCopyAssign_QualCVRvalue), "");
+
+  // Non-referencable types
+  static_assert(!__is_copy_assignable(void), "");
+  static_assert(!__is_nothrow_copy_assignable(void), "");
+  static_assert(!__is_trivially_copy_assignable(void), "");
+
+  static_assert(!__is_copy_assignable(void()), "");
+  static_assert(!__is_nothrow_copy_assignable(void()), "");
+  static_assert(!__is_trivially_copy_assignable(void()), "");
+
+  // cv-qualified types
+  static_assert(!__is_copy_assignable(const int), "");
+  static_assert(!__is_nothrow_copy_assignable(const int), "");
+  static_assert(!__is_trivially_copy_assignable(const int), "");
+
+  static_assert(!__is_copy_assignable(const Empty), "");
+  static_assert(!__is_nothrow_copy_assignable(const Empty), "");
+  static_assert(!__is_trivially_copy_assignable(const Empty), "");
+
+  static_assert(__is_copy_assignable(volatile int), "");
+  static_assert(__is_nothrow_copy_assignable(volatile int), "");
+  static_assert(__is_trivially_copy_assignable(volatile int), "");
+
+  static_assert(!__is_copy_assignable(volatile Empty), "");
+  static_assert(!__is_nothrow_copy_assignable(volatile Empty), "");
+  static_assert(!__is_trivially_copy_assignable(volatile Empty), "");
+
+  static_assert(!__is_copy_assignable(const volatile int), "");
+  static_assert(!__is_nothrow_copy_assignable(const volatile int), "");
+  static_assert(!__is_trivially_copy_assignable(const volatile int), "");
+
+  static_assert(!__is_copy_assignable(const volatile Empty), "");
+  static_assert(!__is_nothrow_copy_assignable(const volatile Empty), "");
+  static_assert(!__is_trivially_copy_assignable(const volatile Empty), "");
+
+  static_assert(__is_copy_assignable(const CopyAssign_QualConst), "");
+  static_assert(!__is_nothrow_copy_assignable(const CopyAssign_QualConst), "");
+  static_assert(!__is_trivially_copy_assignable(const CopyAssign_QualConst), "");
+
+  static_assert(!__is_copy_assignable(volatile CopyAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_copy_assignable(volatile CopyAssign_QualVolatile), "");
+  static_assert(!__is_trivially_copy_assignable(volatile CopyAssign_QualVolatile), "");
+
+  static_assert(!__is_copy_assignable(const volatile CopyAssign_QualCV), "");
+  static_assert(!__is_nothrow_copy_assignable(const volatile CopyAssign_QualCV), "");
+  static_assert(!__is_trivially_copy_assignable(const volatile CopyAssign_QualCV), "");
+
+  static_assert(!__is_copy_assignable(const VolatileCopyAssign_QualConst), "");
+  static_assert(!__is_nothrow_copy_assignable(const VolatileCopyAssign_QualConst), "");
+  static_assert(!__is_trivially_copy_assignable(const VolatileCopyAssign_QualConst), "");
+
+  static_assert(!__is_copy_assignable(volatile VolatileCopyAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_copy_assignable(volatile VolatileCopyAssign_QualVolatile), "");
+  static_assert(!__is_trivially_copy_assignable(volatile VolatileCopyAssign_QualVolatile), "");
+
+  static_assert(!__is_copy_assignable(const volatile VolatileCopyAssign_QualCV), "");
+  static_assert(!__is_nothrow_copy_assignable(const volatile VolatileCopyAssign_QualCV), "");
+  static_assert(!__is_trivially_copy_assignable(const volatile VolatileCopyAssign_QualCV), "");
+
+  static_assert(__is_copy_assignable(const CVCopyAssign_QualConst), "");
+  static_assert(!__is_nothrow_copy_assignable(const CVCopyAssign_QualConst), "");
+  static_assert(!__is_trivially_copy_assignable(const CVCopyAssign_QualConst), "");
+
+  static_assert(__is_copy_assignable(volatile CVCopyAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_copy_assignable(volatile CVCopyAssign_QualVolatile), "");
+  static_assert(!__is_trivially_copy_assignable(volatile CVCopyAssign_QualVolatile), "");
+
+  static_assert(__is_copy_assignable(const volatile CVCopyAssign_QualCV), "");
+  static_assert(!__is_nothrow_copy_assignable(const volatile CVCopyAssign_QualCV), "");
+  static_assert(!__is_trivially_copy_assignable(const volatile CVCopyAssign_QualCV), "");
+}
+
 // Instantiation of __is_trivially_constructible
 template<typename T, typename ...Args>
 struct is_trivially_constructible {
   static const bool value = __is_trivially_constructible(T, Args...);
 };
 
 void is_trivially_constructible_test() {
   { int arr[T((is_trivially_constructible<int>::value))]; }