[clang] adds move-assignable type-trait builtins

[cjdb]

Summary

• __is_move_assignable
• __is_nothrow_move_assignable
• __is_trivially_move_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_move_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 move
assignment.

This was originally a part of D116280.

Depends on D135240.

[erichkeane]

Once again, concerns about triviality.

[cjdb]

Abandoning, since this doesn't have consensus.

clang/include/clang/Basic/TokenKinds.def

 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)
 TYPE_TRAIT_1(__is_move_constructible, IsMoveConstructible, KEYCXX)
 TYPE_TRAIT_1(__is_nothrow_move_constructible, IsNothrowMoveConstructible, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_move_constructible, IsTriviallyMoveConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_move_assignable, IsMoveAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_move_assignable, IsNothrowMoveAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_move_assignable, IsTriviallyMoveAssignable, 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)
 TYPE_TRAIT_1(__is_floating_point, IsFloatingPoint, KEYCXX)

clang/lib/Parse/ParseDeclCXX.cpp

#include "clang/Basic/TransformTypeTraits.def"
           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_move_assignable,
           tok::kw___is_move_constructible,
           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_nothrow_move_assignable,
           tok::kw___is_nothrow_move_constructible,
           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_trivially_move_assignable,
           tok::kw___is_trivially_move_constructible,
           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
     // name of struct templates, but some are keywords in GCC >= 4.3

clang/lib/Parse/ParseExpr.cpp

#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           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_move_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_move_constructible);
           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_move_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_move_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_trivially_move_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_move_constructible);
           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)                                     \
   REVERTIBLE_TYPE_TRAIT(RTT_JOIN(__, Trait));

clang/lib/Sema/SemaExprCXX.cpp

static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   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;
 
     return !S.RequireCompleteType(
         Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
   }
 }
 
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_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, {});

 void DiagnoseBuiltinDeprecation(Sema& S, TypeTrait Kind,
                                 SourceLocation KWLoc) {
   TypeTrait Replacement;
   switch (Kind) {
   case UTT_HasNothrowAssign: // despite its name, this checks copy assignment
     Replacement = UTT_IsNothrowCopyAssignable;
     break;
   case UTT_HasNothrowMoveAssign:
-    Replacement = BTT_IsNothrowAssignable;
+    Replacement = UTT_IsNothrowMoveAssignable;
     break;
   case UTT_HasNothrowCopy:
     Replacement = UTT_IsNothrowCopyConstructible;
     break;
   case UTT_HasNothrowConstructor:
     Replacement = TT_IsNothrowConstructible;
     break;
   case UTT_HasTrivialAssign: // despite its name, this checks copy assignment
     Replacement = UTT_IsTriviallyCopyAssignable;
     break;
   case UTT_HasTrivialMoveAssign:
-    Replacement = BTT_IsTriviallyAssignable;
+    Replacement = UTT_IsTriviallyMoveAssignable;
     break;
   case UTT_HasTrivialCopy:
     Replacement = UTT_IsTriviallyCopyConstructible;
     break;
   case UTT_HasTrivialDefaultConstructor:
     Replacement = TT_IsTriviallyConstructible;
     break;
   case UTT_HasTrivialMoveConstructor:

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_copy_assignable}}
-    a = __has_nothrow_move_assign(A);  // expected-warning-re {{__has_nothrow_move_assign {{.*}} use __is_nothrow_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_copy_assignable}}
-    a = __has_trivial_move_assign(A);  // expected-warning-re {{__has_trivial_move_assign {{.*}} use __is_trivially_assignable}}
+    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_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_move_constructible}}
     a = __has_trivial_destructor(A);  // expected-warning-re {{__has_trivial_destructor {{.*}} use __is_trivially_destructible}}
 
 }

clang/test/SemaCXX/type-traits.cpp

void copy_assignable_checks() {
   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), "");
 }
 
+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
+  static_assert(__is_move_assignable(int), "");
+  static_assert(__is_nothrow_move_assignable(int), "");
+  static_assert(__is_trivially_move_assignable(int), "");
+
+  static_assert(__is_move_assignable(int &), "");
+  static_assert(__is_nothrow_move_assignable(int &), "");
+  static_assert(__is_trivially_move_assignable(int &), "");
+
+  static_assert(__is_move_assignable(int &&), "");
+  static_assert(__is_nothrow_move_assignable(int &&), "");
+  static_assert(__is_trivially_move_assignable(int &&), "");
+
+  static_assert(__is_move_assignable(int *), "");
+  static_assert(__is_nothrow_move_assignable(int *), "");
+  static_assert(__is_trivially_move_assignable(int *), "");
+
+  static_assert(!__is_move_assignable(int[5]), "");
+  static_assert(!__is_nothrow_move_assignable(int[5]), "");
+  static_assert(!__is_trivially_move_assignable(int[5]), "");
+
+  static_assert(!__is_move_assignable(int[]), "");
+  static_assert(!__is_nothrow_move_assignable(int[]), "");
+  static_assert(!__is_trivially_move_assignable(int[]), "");
+
+  static_assert(__is_move_assignable(decltype(nullptr)), "");
+  static_assert(__is_nothrow_move_assignable(decltype(nullptr)), "");
+  static_assert(__is_trivially_move_assignable(decltype(nullptr)), "");
+
+  static_assert(__is_move_assignable(void (*)()), "");
+  static_assert(__is_nothrow_move_assignable(void (*)()), "");
+  static_assert(__is_trivially_move_assignable(void (*)()), "");
+
+  static_assert(!__is_move_assignable(void (&)()), "");
+  static_assert(!__is_nothrow_move_assignable(void (&)()), "");
+  static_assert(!__is_trivially_move_assignable(void (&)()), "");
+
+  static_assert(__is_move_assignable(int Empty::*), "");
+  static_assert(__is_nothrow_move_assignable(int Empty::*), "");
+  static_assert(__is_trivially_move_assignable(int Empty::*), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)()), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)()), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)()), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() const), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() const), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() const), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() volatile), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() volatile), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() volatile), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() const volatile), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() const volatile), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() const volatile), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() &), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() &), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() &), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() const &), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() const &), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() const &), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() volatile &), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() volatile &), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() volatile &), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() const volatile &), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() const volatile &), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() const volatile &), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() &&), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() &&), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() &&), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() const &&), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() const &&), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() const &&), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() volatile &&), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() volatile &&), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() volatile &&), "");
+
+  static_assert(__is_move_assignable(int(Empty::*)() const volatile &&), "");
+  static_assert(__is_nothrow_move_assignable(int(Empty::*)() const volatile &&), "");
+  static_assert(__is_trivially_move_assignable(int(Empty::*)() const volatile &&), "");
+
+  // // User-defined types
+  static_assert(__is_move_assignable(AllDefaulted), "");
+  static_assert(__is_nothrow_move_assignable(AllDefaulted), "");
+  static_assert(__is_trivially_move_assignable(AllDefaulted), "");
+
+  static_assert(__is_move_assignable(BaseDeletedCopyCtor), "");
+  static_assert(__is_nothrow_move_assignable(BaseDeletedCopyCtor), "");
+  static_assert(__is_trivially_move_assignable(BaseDeletedCopyCtor), "");
+
+  static_assert(__is_move_assignable(CEmptyStruct), "");
+  static_assert(__is_nothrow_move_assignable(CEmptyStruct), "");
+  static_assert(__is_trivially_move_assignable(CEmptyStruct), "");
+
+  static_assert(__is_move_assignable(CopyCtorDeleted), "");
+  static_assert(__is_nothrow_move_assignable(CopyCtorDeleted), "");
+  static_assert(__is_trivially_move_assignable(CopyCtorDeleted), "");
+
+  static_assert(__is_move_assignable(CppEmptyStruct), "");
+  static_assert(__is_nothrow_move_assignable(CppEmptyStruct), "");
+  static_assert(__is_trivially_move_assignable(CppEmptyStruct), "");
+
+  static_assert(__is_move_assignable(CppStructNonStandardBy2ndVirtBase), "");
+  static_assert(__is_nothrow_move_assignable(CppStructNonStandardBy2ndVirtBase), "");
+  static_assert(__is_trivially_move_assignable(CppStructNonStandardBy2ndVirtBase), "");
+
+  static_assert(__is_move_assignable(CppStructNonStandardByBase), "");
+  static_assert(__is_nothrow_move_assignable(CppStructNonStandardByBase), "");
+  static_assert(__is_trivially_move_assignable(CppStructNonStandardByBase), "");
+
+  static_assert(__is_move_assignable(CppStructNonStandardByMemb), "");
+  static_assert(__is_nothrow_move_assignable(CppStructNonStandardByMemb), "");
+  static_assert(!__is_trivially_move_assignable(CppStructNonStandardByMemb), "");
+
+  static_assert(__is_move_assignable(CppStructNonStandardByProt), "");
+  static_assert(__is_nothrow_move_assignable(CppStructNonStandardByProt), "");
+  static_assert(__is_trivially_move_assignable(CppStructNonStandardByProt), "");
+
+  static_assert(__is_move_assignable(CppStructNonStandardBySameBase), "");
+  static_assert(__is_nothrow_move_assignable(CppStructNonStandardBySameBase), "");
+  static_assert(__is_trivially_move_assignable(CppStructNonStandardBySameBase), "");
+
+  static_assert(__is_move_assignable(CppStructNonStandardByVirt), "");
+  static_assert(__is_nothrow_move_assignable(CppStructNonStandardByVirt), "");
+  static_assert(!__is_trivially_move_assignable(CppStructNonStandardByVirt), "");
+
+  static_assert(__is_move_assignable(CppStructNonStandardByVirtBase), "");
+  static_assert(__is_nothrow_move_assignable(CppStructNonStandardByVirtBase), "");
+  static_assert(!__is_trivially_move_assignable(CppStructNonStandardByVirtBase), "");
+
+  static_assert(__is_move_assignable(CppStructStandard), "");
+  static_assert(__is_nothrow_move_assignable(CppStructStandard), "");
+  static_assert(__is_trivially_move_assignable(CppStructStandard), "");
+
+  static_assert(__is_move_assignable(CStruct), "");
+  static_assert(__is_nothrow_move_assignable(CStruct), "");
+  static_assert(__is_trivially_move_assignable(CStruct), "");
+
+  static_assert(__is_move_assignable(CVCopyCtor), "");
+  static_assert(__is_nothrow_move_assignable(CVCopyCtor), "");
+  static_assert(__is_trivially_move_assignable(CVCopyCtor), "");
+
+  static_assert(__is_move_assignable(Derives), "");
+  static_assert(__is_nothrow_move_assignable(Derives), "");
+  static_assert(__is_trivially_move_assignable(Derives), "");
+
+  static_assert(__is_move_assignable(DerivesHasCopyAssign), "");
+  static_assert(!__is_nothrow_move_assignable(DerivesHasCopyAssign), "");
+  static_assert(!__is_trivially_move_assignable(DerivesHasCopyAssign), "");
+
+  static_assert(__is_move_assignable(Empty), "");
+  static_assert(__is_nothrow_move_assignable(Empty), "");
+  static_assert(__is_trivially_move_assignable(Empty), "");
+
+  static_assert(__is_move_assignable(EmptyUnion), "");
+  static_assert(__is_nothrow_move_assignable(EmptyUnion), "");
+  static_assert(__is_trivially_move_assignable(EmptyUnion), "");
+
+  static_assert(__is_move_assignable(Enum), "");
+  static_assert(__is_nothrow_move_assignable(Enum), "");
+  static_assert(__is_trivially_move_assignable(Enum), "");
+
+  static_assert(__is_move_assignable(EnumClass), "");
+  static_assert(__is_nothrow_move_assignable(EnumClass), "");
+  static_assert(__is_trivially_move_assignable(EnumClass), "");
+
+  static_assert(__is_move_assignable(ExtDefaulted), "");
+  static_assert(!__is_nothrow_move_assignable(ExtDefaulted), "");
+  static_assert(!__is_trivially_move_assignable(ExtDefaulted), "");
+
+  static_assert(__is_move_assignable(HasCons), "");
+  static_assert(__is_nothrow_move_assignable(HasCons), "");
+  static_assert(__is_trivially_move_assignable(HasCons), "");
+
+  static_assert(__is_move_assignable(HasCopyAssign), "");
+  static_assert(!__is_nothrow_move_assignable(HasCopyAssign), "");
+  static_assert(!__is_trivially_move_assignable(HasCopyAssign), "");
+
+  static_assert(__is_move_assignable(HasDest), "");
+  static_assert(__is_nothrow_move_assignable(HasDest), "");
+  static_assert(__is_trivially_move_assignable(HasDest), "");
+
+  static_assert(__is_move_assignable(HasMutableCopyCtor), "");
+  static_assert(__is_nothrow_move_assignable(HasMutableCopyCtor), "");
+  static_assert(__is_trivially_move_assignable(HasMutableCopyCtor), "");
+
+  static_assert(__is_move_assignable(HasPriv), "");
+  static_assert(__is_nothrow_move_assignable(HasPriv), "");
+  static_assert(__is_trivially_move_assignable(HasPriv), "");
+
+  static_assert(__is_move_assignable(HasMultipleCopyAssign), "");
+  static_assert(__is_nothrow_move_assignable(HasMultipleCopyAssign), "");
+  static_assert(!__is_trivially_move_assignable(HasMultipleCopyAssign), "");
+
+  static_assert(__is_move_assignable(HasTemplateCons), "");
+  static_assert(__is_nothrow_move_assignable(HasTemplateCons), "");
+  static_assert(!__is_trivially_move_assignable(HasTemplateCons), "");
+
+  static_assert(__is_move_assignable(MemberDeletedCopyCtor), "");
+  static_assert(__is_nothrow_move_assignable(MemberDeletedCopyCtor), "");
+  static_assert(__is_trivially_move_assignable(MemberDeletedCopyCtor), "");
+
+  static_assert(__is_move_assignable(NoDefaultMoveAssignDueToDtor), "");
+  static_assert(__is_nothrow_move_assignable(NoDefaultMoveAssignDueToDtor), "");
+  static_assert(__is_trivially_move_assignable(NoDefaultMoveAssignDueToDtor), "");
+
+  static_assert(__is_move_assignable(NoDefaultMoveAssignDueToUDCopyAssign), "");
+  static_assert(!__is_nothrow_move_assignable(NoDefaultMoveAssignDueToUDCopyAssign), "");
+  static_assert(!__is_trivially_move_assignable(NoDefaultMoveAssignDueToUDCopyAssign), "");
+
+  static_assert(__is_move_assignable(NoDefaultMoveAssignDueToUDCopyCtor), "");
+  static_assert(__is_nothrow_move_assignable(NoDefaultMoveAssignDueToUDCopyCtor), "");
+  static_assert(__is_trivially_move_assignable(NoDefaultMoveAssignDueToUDCopyCtor), "");
+
+  static_assert(__is_move_assignable(NonTCStruct), "");
+  static_assert(__is_nothrow_move_assignable(NonTCStruct), "");
+  static_assert(__is_trivially_move_assignable(NonTCStruct), "");
+
+  static_assert(__is_move_assignable(NonTrivialStruct), "");
+  static_assert(__is_nothrow_move_assignable(NonTrivialStruct), "");
+  static_assert(__is_trivially_move_assignable(NonTrivialStruct), "");
+
+  static_assert(__is_move_assignable(POD), "");
+  static_assert(__is_nothrow_move_assignable(POD), "");
+  static_assert(__is_trivially_move_assignable(POD), "");
+
+  static_assert(__is_move_assignable(SuperNonTrivialStruct), "");
+  static_assert(__is_nothrow_move_assignable(SuperNonTrivialStruct), "");
+  static_assert(__is_trivially_move_assignable(SuperNonTrivialStruct), "");
+
+  static_assert(__is_move_assignable(TrivialStruct), "");
+  static_assert(__is_nothrow_move_assignable(TrivialStruct), "");
+  static_assert(__is_trivially_move_assignable(TrivialStruct), "");
+
+  static_assert(__is_move_assignable(Union), "");
+  static_assert(__is_nothrow_move_assignable(Union), "");
+  static_assert(__is_trivially_move_assignable(Union), "");
+
+  static_assert(__is_move_assignable(HasMoveAssign), "");
+  static_assert(!__is_nothrow_move_assignable(HasMoveAssign), "");
+  static_assert(!__is_trivially_move_assignable(HasMoveAssign), "");
+
+  static_assert(__is_move_assignable(HasNoThrowMoveAssign), "");
+  static_assert(__is_nothrow_move_assignable(HasNoThrowMoveAssign), "");
+  static_assert(!__is_trivially_move_assignable(HasNoThrowMoveAssign), "");
+
+  static_assert(!__is_move_assignable(AllDeleted), "");
+  static_assert(!__is_nothrow_move_assignable(AllDeleted), "");
+  static_assert(!__is_trivially_move_assignable(AllDeleted), "");
+
+  static_assert(!__is_move_assignable(AllPrivate), "");
+  static_assert(!__is_nothrow_move_assignable(AllPrivate), "");
+  static_assert(!__is_trivially_move_assignable(AllPrivate), "");
+
+  static_assert(!__is_move_assignable(AnIncompleteType[]), "");
+  static_assert(!__is_nothrow_move_assignable(AnIncompleteType[]), "");
+  static_assert(!__is_trivially_move_assignable(AnIncompleteType[]), "");
+
+  static_assert(!__is_move_assignable(AnIncompleteType), ""); // expected-error{{incomplete type}}
+  static_assert(!__is_nothrow_move_assignable(AnIncompleteType), ""); // expected-error{{incomplete type}}
+  static_assert(!__is_trivially_move_assignable(AnIncompleteType), ""); // expected-error{{incomplete type}}
+
+  static_assert(!__is_move_assignable(DerivesHasRef), "");
+  static_assert(!__is_nothrow_move_assignable(DerivesHasRef), "");
+  static_assert(!__is_trivially_move_assignable(DerivesHasRef), "");
+
+  static_assert(!__is_move_assignable(HasRef), "");
+  static_assert(!__is_nothrow_move_assignable(HasRef), "");
+  static_assert(!__is_trivially_move_assignable(HasRef), "");
+
+  static_assert(!__is_move_assignable(HasMove), "");
+  static_assert(!__is_nothrow_move_assignable(HasMove), "");
+  static_assert(!__is_trivially_move_assignable(HasMove), "");
+
+  static_assert(!__is_move_assignable(VirtAr), "");
+  static_assert(!__is_nothrow_move_assignable(VirtAr), "");
+  static_assert(!__is_trivially_move_assignable(VirtAr), "");
+
+  static_assert(!__is_move_assignable(MoveAssignDeleted), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssignDeleted), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssignDeleted), "");
+
+  static_assert(!__is_move_assignable(BaseDeletedMoveAssign), "");
+  static_assert(!__is_nothrow_move_assignable(BaseDeletedMoveAssign), "");
+  static_assert(!__is_trivially_move_assignable(BaseDeletedMoveAssign), "");
+
+  static_assert(!__is_move_assignable(HasMemberWithDeletedMoveAssign), "");
+  static_assert(!__is_nothrow_move_assignable(HasMemberWithDeletedMoveAssign), "");
+  static_assert(!__is_trivially_move_assignable(HasMemberWithDeletedMoveAssign), "");
+
+  static_assert(__is_move_assignable(MoveAssign_QualNone), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualNone), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualNone), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualConst), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualVolatile), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualVolatile), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualCV), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualCV), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualCV), "");
+
+  static_assert(__is_move_assignable(MoveAssign_QualLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualLvalue), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualLvalue), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualConstLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualConstLvalue), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualConstLvalue), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualVolatileLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualVolatileLvalue), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualVolatileLvalue), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualCVLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualCVLvalue), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualCVLvalue), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualRvalue), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualRvalue), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualConstRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualConstRvalue), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualConstRvalue), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualVolatileRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualVolatileRvalue), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualVolatileRvalue), "");
+
+  static_assert(!__is_move_assignable(MoveAssign_QualCVRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(MoveAssign_QualCVRvalue), "");
+  static_assert(!__is_trivially_move_assignable(MoveAssign_QualCVRvalue), "");
+
+  static_assert(__is_move_assignable(ConstMoveAssign_QualNone), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualNone), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualNone), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualConst), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualVolatile), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualVolatile), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualCV), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualCV), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualCV), "");
+
+  static_assert(__is_move_assignable(ConstMoveAssign_QualLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualLvalue), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualLvalue), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualConstLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualConstLvalue), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualConstLvalue), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualVolatileLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualVolatileLvalue), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualVolatileLvalue), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualCVLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualCVLvalue), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualCVLvalue), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualRvalue), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualRvalue), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualConstRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualConstRvalue), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualConstRvalue), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualVolatileRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualVolatileRvalue), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualVolatileRvalue), "");
+
+  static_assert(!__is_move_assignable(ConstMoveAssign_QualCVRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(ConstMoveAssign_QualCVRvalue), "");
+  static_assert(!__is_trivially_move_assignable(ConstMoveAssign_QualCVRvalue), "");
+
+  static_assert(__is_move_assignable(VolatileMoveAssign_QualNone), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualNone), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualNone), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualConst), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualVolatile), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualVolatile), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualCV), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualCV), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualCV), "");
+
+  static_assert(__is_move_assignable(VolatileMoveAssign_QualLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualLvalue), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualLvalue), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualConstLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualConstLvalue), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualConstLvalue), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualVolatileLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualVolatileLvalue), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualVolatileLvalue), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualCVLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualCVLvalue), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualCVLvalue), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualRvalue), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualRvalue), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualConstRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualConstRvalue), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualConstRvalue), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualVolatileRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualVolatileRvalue), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualVolatileRvalue), "");
+
+  static_assert(!__is_move_assignable(VolatileMoveAssign_QualCVRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(VolatileMoveAssign_QualCVRvalue), "");
+  static_assert(!__is_trivially_move_assignable(VolatileMoveAssign_QualCVRvalue), "");
+
+  static_assert(__is_move_assignable(CVMoveAssign_QualNone), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualNone), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualNone), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualConst), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualVolatile), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualVolatile), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualCV), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualCV), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualCV), "");
+
+  static_assert(__is_move_assignable(CVMoveAssign_QualLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualLvalue), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualLvalue), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualConstLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualConstLvalue), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualConstLvalue), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualVolatileLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualVolatileLvalue), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualVolatileLvalue), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualCVLvalue), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualCVLvalue), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualCVLvalue), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualRvalue), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualRvalue), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualConstRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualConstRvalue), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualConstRvalue), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualVolatileRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualVolatileRvalue), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualVolatileRvalue), "");
+
+  static_assert(!__is_move_assignable(CVMoveAssign_QualCVRvalue), "");
+  static_assert(!__is_nothrow_move_assignable(CVMoveAssign_QualCVRvalue), "");
+  static_assert(!__is_trivially_move_assignable(CVMoveAssign_QualCVRvalue), "");
+
+
+  // Non-referencable types
+  static_assert(!__is_move_assignable(void), "");
+  static_assert(!__is_nothrow_move_assignable(void), "");
+  static_assert(!__is_trivially_move_assignable(void), "");
+
+  static_assert(!__is_move_assignable(void()), "");
+  static_assert(!__is_nothrow_move_assignable(void()), "");
+  static_assert(!__is_trivially_move_assignable(void()), "");
+
+  // cv-qualified types
+  static_assert(!__is_move_assignable(const int), "");
+  static_assert(!__is_nothrow_move_assignable(const int), "");
+  static_assert(!__is_trivially_move_assignable(const int), "");
+
+  static_assert(!__is_move_assignable(const Empty), "");
+  static_assert(!__is_nothrow_move_assignable(const Empty), "");
+  static_assert(!__is_trivially_move_assignable(const Empty), "");
+
+  static_assert(__is_move_assignable(volatile int), "");
+  static_assert(__is_nothrow_move_assignable(volatile int), "");
+  static_assert(__is_trivially_move_assignable(volatile int), "");
+
+  static_assert(!__is_move_assignable(volatile Empty), "");
+  static_assert(!__is_nothrow_move_assignable(volatile Empty), "");
+  static_assert(!__is_trivially_move_assignable(volatile Empty), "");
+
+  static_assert(!__is_move_assignable(const volatile int), "");
+  static_assert(!__is_nothrow_move_assignable(const volatile int), "");
+  static_assert(!__is_trivially_move_assignable(const volatile int), "");
+
+  static_assert(!__is_move_assignable(const volatile Empty), "");
+  static_assert(!__is_nothrow_move_assignable(const volatile Empty), "");
+  static_assert(!__is_trivially_move_assignable(const volatile Empty), "");
+
+  static_assert(!__is_move_assignable(const MoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(const MoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(const MoveAssign_QualConst), "");
+
+  static_assert(!__is_move_assignable(volatile MoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(volatile MoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(volatile MoveAssign_QualConst), "");
+
+  static_assert(!__is_move_assignable(const volatile MoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(const volatile MoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(const volatile MoveAssign_QualConst), "");
+
+  static_assert(!__is_move_assignable(volatile MoveAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_move_assignable(volatile MoveAssign_QualVolatile), "");
+  static_assert(!__is_trivially_move_assignable(volatile MoveAssign_QualVolatile), "");
+
+  static_assert(!__is_move_assignable(const volatile MoveAssign_QualCV), "");
+  static_assert(!__is_nothrow_move_assignable(const volatile MoveAssign_QualCV), "");
+  static_assert(!__is_trivially_move_assignable(const volatile MoveAssign_QualCV), "");
+
+  static_assert(!__is_move_assignable(const VolatileMoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(const VolatileMoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(const VolatileMoveAssign_QualConst), "");
+
+  static_assert(__is_move_assignable(volatile VolatileMoveAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_move_assignable(volatile VolatileMoveAssign_QualVolatile), "");
+  static_assert(!__is_trivially_move_assignable(volatile VolatileMoveAssign_QualVolatile), "");
+
+  static_assert(!__is_move_assignable(const volatile VolatileMoveAssign_QualCV), "");
+  static_assert(!__is_nothrow_move_assignable(const volatile VolatileMoveAssign_QualCV), "");
+  static_assert(!__is_trivially_move_assignable(const volatile VolatileMoveAssign_QualCV), "");
+
+  static_assert(__is_move_assignable(const CVMoveAssign_QualConst), "");
+  static_assert(!__is_nothrow_move_assignable(const CVMoveAssign_QualConst), "");
+  static_assert(!__is_trivially_move_assignable(const CVMoveAssign_QualConst), "");
+
+  static_assert(__is_move_assignable(volatile CVMoveAssign_QualVolatile), "");
+  static_assert(!__is_nothrow_move_assignable(volatile CVMoveAssign_QualVolatile), "");
+  static_assert(!__is_trivially_move_assignable(volatile CVMoveAssign_QualVolatile), "");
+
+  static_assert(__is_move_assignable(const volatile CVMoveAssign_QualCV), "");
+  static_assert(!__is_nothrow_move_assignable(const volatile CVMoveAssign_QualCV), "");
+  static_assert(!__is_trivially_move_assignable(const volatile CVMoveAssign_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))]; }