[clang] adds move-constructible type-trait builtins

[cjdb]

Summary

• __is_move_constructible
• __is_nothrow_move_constructible
• __is_trivially_move_constructible

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.

Unlike their default-constructible cousins, the move-constructible
traits can't be implemented using __is_constructible, etc., because we
can't form references to void, and references are a fundamental part
of move constructors.

This was originally a part of D116280.

Depends on D135239.

[erichkeane]

Same comments on triviality here unfortunately.

[cjdb]

Abandoning, since this doesn't have consensus.

clang/include/clang/Basic/TokenKinds.def

 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)
+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)
 
 // 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_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_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_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
     // and Clang. Therefore, when we see the token sequence "struct

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_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_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_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));
 #include "clang/Basic/TransformTypeTraits.def"

clang/lib/Sema/SemaExprCXX.cpp

static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   case UTT_IsTriviallyDestructible:
   case UTT_HasUniqueObjectRepresentations:
   case UTT_IsCopyConstructible:
   case UTT_IsTriviallyCopyConstructible:
   case UTT_IsNothrowCopyConstructible:
   case UTT_IsCopyAssignable:
   case UTT_IsTriviallyCopyAssignable:
   case UTT_IsNothrowCopyAssignable:
+  case UTT_IsMoveConstructible:
+  case UTT_IsTriviallyMoveConstructible:
+  case UTT_IsNothrowMoveConstructible:
     if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
       return true;
 
     return !S.RequireCompleteType(
         Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
   }
 }
 
llvm::SmallVector<TypeSourceInfo *, 2> Parameters = {
         C.CreateTypeSourceInfo(T), C.CreateTypeSourceInfo(AssigneeType)};
     return evaluateTypeTrait(Self,
                              UTT == UTT_IsCopyConstructible ? TT_IsConstructible
                              : UTT == UTT_IsTriviallyCopyConstructible
                                  ? TT_IsTriviallyConstructible
                                  : TT_IsNothrowConstructible,
                              KeyLoc, Parameters, {});
   }
+  case UTT_IsMoveConstructible:
+  case UTT_IsTriviallyMoveConstructible:
+  case UTT_IsNothrowMoveConstructible: {
+    if (T->isIncompleteArrayType())
+      return false;
+    if (!T.isReferenceable())
+      return false;
+
+    QualType AssigneeType = Self.BuiltinAddReference(
+        T, UnaryTransformType::AddRvalueReference, KeyLoc);
+    llvm::SmallVector<TypeSourceInfo *, 2> Parameters = {
+        C.CreateTypeSourceInfo(T), C.CreateTypeSourceInfo(AssigneeType)};
+    return evaluateTypeTrait(Self,
+                             UTT == UTT_IsMoveConstructible ? TT_IsConstructible
+                             : UTT == UTT_IsTriviallyMoveConstructible
+                                 ? TT_IsTriviallyConstructible
+                                 : TT_IsNothrowConstructible,
+                             KeyLoc, Parameters, {});
+  }
   case UTT_IsReferenceable:
     return T.isReferenceable();
   }
 }
 
 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
                                     QualType RhsT, SourceLocation KeyLoc);
 
case UTT_HasTrivialAssign: // despite its name, this checks copy assignment
     break;
   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_HasTrivialMoveConstructor:
+    Replacement = UTT_IsTriviallyMoveConstructible;
+    break;
   case UTT_HasTrivialDestructor:
     Replacement = UTT_IsTriviallyDestructible;
     break;
   default:
     return;
   }
   S.Diag(KWLoc, diag::warn_deprecated_builtin)
     << getTraitSpelling(Kind) << getTraitSpelling(Replacement);

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_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_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_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_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 ConstMoveCtor {
+  ConstMoveCtor(const ConstMoveCtor &&);
+};
+
+struct VolatileMoveCtor {
+  VolatileMoveCtor(volatile VolatileMoveCtor &&);
+};
+
+struct CVMoveCtor {
+  CVMoveCtor(const volatile CVMoveCtor &&);
+};
+
+struct MoveCtorDeleted {
+  MoveCtorDeleted(MoveCtorDeleted &&) = delete;
+};
+
+struct BaseDeletedMoveCtor : MoveCtorDeleted {};
+
+struct MemberDeletedMoveCtor {
+  MoveCtorDeleted x;
+};
+
+struct HasNothrowMoveCtor {
+  HasNothrowMoveCtor(HasNothrowMoveCtor&&) noexcept;
+};
+
+void move_constructible_checks() {
+  // Builtin types
+  static_assert(__is_move_constructible(int), "");
+  static_assert(__is_nothrow_move_constructible(int), "");
+  static_assert(__is_trivially_move_constructible(int), "");
+
+  static_assert(__is_move_constructible(const int), "");
+  static_assert(__is_nothrow_move_constructible(const int), "");
+  static_assert(__is_trivially_move_constructible(const int), "");
+
+  static_assert(__is_move_constructible(volatile int), "");
+  static_assert(__is_nothrow_move_constructible(volatile int), "");
+  static_assert(__is_trivially_move_constructible(volatile int), "");
+
+  static_assert(__is_move_constructible(const volatile int), "");
+  static_assert(__is_nothrow_move_constructible(const volatile int), "");
+  static_assert(__is_trivially_move_constructible(const volatile int), "");
+
+  static_assert(__is_move_constructible(int&), "");
+  static_assert(__is_nothrow_move_constructible(int&), "");
+  static_assert(__is_trivially_move_constructible(int&), "");
+
+  static_assert(__is_move_constructible(const int&), "");
+  static_assert(__is_nothrow_move_constructible(const int&), "");
+  static_assert(__is_trivially_move_constructible(const int&), "");
+
+  static_assert(__is_move_constructible(volatile int&), "");
+  static_assert(__is_nothrow_move_constructible(volatile int&), "");
+  static_assert(__is_trivially_move_constructible(volatile int&), "");
+
+  static_assert(__is_move_constructible(const volatile int&), "");
+  static_assert(__is_nothrow_move_constructible(const volatile int&), "");
+  static_assert(__is_trivially_move_constructible(const volatile int&), "");
+
+  static_assert(__is_move_constructible(int&&), "");
+  static_assert(__is_nothrow_move_constructible(int&&), "");
+  static_assert(__is_trivially_move_constructible(int&&), "");
+
+  static_assert(__is_move_constructible(const int&&), "");
+  static_assert(__is_nothrow_move_constructible(const int&&), "");
+  static_assert(__is_trivially_move_constructible(const int&&), "");
+
+  static_assert(__is_move_constructible(volatile int&&), "");
+  static_assert(__is_nothrow_move_constructible(volatile int&&), "");
+  static_assert(__is_trivially_move_constructible(volatile int&&), "");
+
+  static_assert(__is_move_constructible(const volatile int&&), "");
+  static_assert(__is_nothrow_move_constructible(const volatile int&&), "");
+  static_assert(__is_trivially_move_constructible(const volatile int&&), "");
+
+  static_assert(__is_move_constructible(int*), "");
+  static_assert(__is_nothrow_move_constructible(int*), "");
+  static_assert(__is_trivially_move_constructible(int*), "");
+
+  static_assert(__is_move_constructible(int* const), "");
+  static_assert(__is_nothrow_move_constructible(int* const), "");
+  static_assert(__is_trivially_move_constructible(int* const), "");
+
+  static_assert(__is_move_constructible(int* volatile), "");
+  static_assert(__is_nothrow_move_constructible(int* volatile), "");
+  static_assert(__is_trivially_move_constructible(int* volatile), "");
+
+  static_assert(__is_move_constructible(int* const volatile), "");
+  static_assert(__is_nothrow_move_constructible(int* const volatile), "");
+  static_assert(__is_trivially_move_constructible(int* const volatile), "");
+
+  static_assert(!__is_move_constructible(int[5]), "");
+  static_assert(!__is_nothrow_move_constructible(int[5]), "");
+  static_assert(!__is_trivially_move_constructible(int[5]), "");
+
+  static_assert(!__is_move_constructible(int[]), "");
+  static_assert(!__is_nothrow_move_constructible(int[]), "");
+  static_assert(!__is_trivially_move_constructible(int[]), "");
+
+  static_assert(__is_move_constructible(decltype(nullptr)), "");
+  static_assert(__is_nothrow_move_constructible(decltype(nullptr)), "");
+  static_assert(__is_trivially_move_constructible(decltype(nullptr)), "");
+
+  static_assert(__is_move_constructible(void (*)()), "");
+  static_assert(__is_nothrow_move_constructible(void (*)()), "");
+  static_assert(__is_trivially_move_constructible(void (*)()), "");
+
+  static_assert(__is_move_constructible(void (&)()), "");
+  static_assert(__is_nothrow_move_constructible(void (&)()), "");
+  static_assert(__is_trivially_move_constructible(void (&)()), "");
+
+  static_assert(__is_move_constructible(int Empty::*), "");
+  static_assert(__is_nothrow_move_constructible(int Empty::*), "");
+  static_assert(__is_trivially_move_constructible(int Empty::*), "");
+
+  // // User-defined types
+  static_assert(__is_move_constructible(AllDefaulted), "");
+  static_assert(__is_nothrow_move_constructible(AllDefaulted), "");
+  static_assert(__is_trivially_move_constructible(AllDefaulted), "");
+
+  static_assert(__is_move_constructible(const AllDefaulted), "");
+  static_assert(__is_nothrow_move_constructible(const AllDefaulted), "");
+  static_assert(__is_trivially_move_constructible(const AllDefaulted), "");
+
+  static_assert(!__is_move_constructible(volatile AllDefaulted), "");
+  static_assert(!__is_nothrow_move_constructible(volatile AllDefaulted), "");
+  static_assert(!__is_trivially_move_constructible(volatile AllDefaulted), "");
+
+  static_assert(!__is_move_constructible(const volatile AllDefaulted), "");
+  static_assert(!__is_nothrow_move_constructible(const volatile AllDefaulted), "");
+  static_assert(!__is_trivially_move_constructible(const volatile AllDefaulted), "");
+
+  static_assert(__is_move_constructible(CEmptyStruct), "");
+  static_assert(__is_nothrow_move_constructible(CEmptyStruct), "");
+  static_assert(__is_trivially_move_constructible(CEmptyStruct), "");
+
+  static_assert(__is_move_constructible(ConstMoveCtor), "");
+  static_assert(!__is_nothrow_move_constructible(ConstMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(ConstMoveCtor), "");
+
+  static_assert(__is_move_constructible(CppEmptyStruct), "");
+  static_assert(__is_nothrow_move_constructible(CppEmptyStruct), "");
+  static_assert(__is_trivially_move_constructible(CppEmptyStruct), "");
+
+  static_assert(__is_move_constructible(CppStructNonStandardBy2ndVirtBase), "");
+  static_assert(__is_nothrow_move_constructible(CppStructNonStandardBy2ndVirtBase), "");
+  static_assert(__is_trivially_move_constructible(CppStructNonStandardBy2ndVirtBase), "");
+
+  static_assert(__is_move_constructible(CppStructNonStandardByBase), "");
+  static_assert(__is_nothrow_move_constructible(CppStructNonStandardByBase), "");
+  static_assert(__is_trivially_move_constructible(CppStructNonStandardByBase), "");
+
+  static_assert(__is_move_constructible(CppStructNonStandardByMemb), "");
+  static_assert(__is_nothrow_move_constructible(CppStructNonStandardByMemb), "");
+  static_assert(!__is_trivially_move_constructible(CppStructNonStandardByMemb), "");
+
+  static_assert(__is_move_constructible(CppStructNonStandardByProt), "");
+  static_assert(__is_nothrow_move_constructible(CppStructNonStandardByProt), "");
+  static_assert(__is_trivially_move_constructible(CppStructNonStandardByProt), "");
+
+  static_assert(__is_move_constructible(CppStructNonStandardBySameBase), "");
+  static_assert(__is_nothrow_move_constructible(CppStructNonStandardBySameBase), "");
+  static_assert(__is_trivially_move_constructible(CppStructNonStandardBySameBase), "");
+
+  static_assert(__is_move_constructible(CppStructNonStandardByVirt), "");
+  static_assert(__is_nothrow_move_constructible(CppStructNonStandardByVirt), "");
+  static_assert(!__is_trivially_move_constructible(CppStructNonStandardByVirt), "");
+
+  static_assert(__is_move_constructible(CppStructNonStandardByVirtBase), "");
+  static_assert(__is_nothrow_move_constructible(CppStructNonStandardByVirtBase), "");
+  static_assert(!__is_trivially_move_constructible(CppStructNonStandardByVirtBase), "");
+
+  static_assert(__is_move_constructible(CppStructStandard), "");
+  static_assert(__is_nothrow_move_constructible(CppStructStandard), "");
+  static_assert(__is_trivially_move_constructible(CppStructStandard), "");
+
+  static_assert(__is_move_constructible(CStruct), "");
+  static_assert(__is_nothrow_move_constructible(CStruct), "");
+  static_assert(__is_trivially_move_constructible(CStruct), "");
+
+  static_assert(__is_move_constructible(CVMoveCtor), "");
+  static_assert(!__is_nothrow_move_constructible(CVMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(CVMoveCtor), "");
+
+  static_assert(__is_move_constructible(Derives), "");
+  static_assert(__is_nothrow_move_constructible(Derives), "");
+  static_assert(__is_trivially_move_constructible(Derives), "");
+
+  static_assert(__is_move_constructible(DerivesHasRef), "");
+  static_assert(__is_nothrow_move_constructible(DerivesHasRef), "");
+  static_assert(__is_trivially_move_constructible(DerivesHasRef), "");
+
+  static_assert(__is_move_constructible(Empty), "");
+  static_assert(__is_nothrow_move_constructible(Empty), "");
+  static_assert(__is_trivially_move_constructible(Empty), "");
+
+  static_assert(__is_move_constructible(EmptyUnion), "");
+  static_assert(__is_nothrow_move_constructible(EmptyUnion), "");
+  static_assert(__is_trivially_move_constructible(EmptyUnion), "");
+
+  static_assert(__is_move_constructible(Enum), "");
+  static_assert(__is_nothrow_move_constructible(Enum), "");
+  static_assert(__is_trivially_move_constructible(Enum), "");
+
+  static_assert(__is_move_constructible(const Enum), "");
+  static_assert(__is_nothrow_move_constructible(const Enum), "");
+  static_assert(__is_trivially_move_constructible(const Enum), "");
+
+  static_assert(__is_move_constructible(volatile Enum), "");
+  static_assert(__is_nothrow_move_constructible(volatile Enum), "");
+  static_assert(__is_trivially_move_constructible(volatile Enum), "");
+
+  static_assert(__is_move_constructible(const volatile Enum), "");
+  static_assert(__is_nothrow_move_constructible(const volatile Enum), "");
+  static_assert(__is_trivially_move_constructible(const volatile Enum), "");
+
+  static_assert(__is_move_constructible(EnumClass), "");
+  static_assert(__is_nothrow_move_constructible(EnumClass), "");
+  static_assert(__is_trivially_move_constructible(EnumClass), "");
+
+  static_assert(__is_move_constructible(const EnumClass), "");
+  static_assert(__is_nothrow_move_constructible(const EnumClass), "");
+  static_assert(__is_trivially_move_constructible(const EnumClass), "");
+
+  static_assert(__is_move_constructible(volatile EnumClass), "");
+  static_assert(__is_nothrow_move_constructible(volatile EnumClass), "");
+  static_assert(__is_trivially_move_constructible(volatile EnumClass), "");
+
+  static_assert(__is_move_constructible(const volatile EnumClass), "");
+  static_assert(__is_nothrow_move_constructible(const volatile EnumClass), "");
+  static_assert(__is_trivially_move_constructible(const volatile EnumClass), "");
+
+  static_assert(__is_move_constructible(ExtDefaulted), "");
+  static_assert(!__is_nothrow_move_constructible(ExtDefaulted), "");
+  static_assert(!__is_trivially_move_constructible(ExtDefaulted), "");
+
+  static_assert(__is_move_constructible(HasCons), "");
+  static_assert(__is_nothrow_move_constructible(HasCons), "");
+  static_assert(__is_trivially_move_constructible(HasCons), "");
+
+  static_assert(__is_move_constructible(HasCopyAssign), "");
+  static_assert(__is_nothrow_move_constructible(HasCopyAssign), "");
+  static_assert(__is_trivially_move_constructible(HasCopyAssign), "");
+
+  static_assert(__is_move_constructible(HasDest), "");
+  static_assert(__is_nothrow_move_constructible(HasDest), "");
+  static_assert(!__is_trivially_move_constructible(HasDest), "");
+
+  static_assert(__is_move_constructible(HasMove), "");
+  static_assert(!__is_nothrow_move_constructible(HasMove), "");
+  static_assert(!__is_trivially_move_constructible(HasMove), "");
+
+  static_assert(__is_move_constructible(HasPriv), "");
+  static_assert(__is_nothrow_move_constructible(HasPriv), "");
+  static_assert(__is_trivially_move_constructible(HasPriv), "");
+
+  static_assert(__is_move_constructible(HasRef), "");
+  static_assert(__is_nothrow_move_constructible(HasRef), "");
+  static_assert(__is_trivially_move_constructible(HasRef), "");
+
+  static_assert(__is_move_constructible(HasTemplateCons), "");
+  static_assert(__is_nothrow_move_constructible(HasTemplateCons), "");
+  static_assert(!__is_trivially_move_constructible(HasTemplateCons), "");
+
+  static_assert(__is_move_constructible(NoDefaultMoveAssignDueToDtor), "");
+  static_assert(__is_nothrow_move_constructible(NoDefaultMoveAssignDueToDtor), "");
+  static_assert(!__is_trivially_move_constructible(NoDefaultMoveAssignDueToDtor), "");
+
+  static_assert(__is_move_constructible(NoDefaultMoveAssignDueToUDCopyAssign), "");
+  static_assert(__is_nothrow_move_constructible(NoDefaultMoveAssignDueToUDCopyAssign), "");
+  static_assert(__is_trivially_move_constructible(NoDefaultMoveAssignDueToUDCopyAssign), "");
+
+  static_assert(__is_move_constructible(NoDefaultMoveAssignDueToUDCopyCtor), "");
+  static_assert(!__is_nothrow_move_constructible(NoDefaultMoveAssignDueToUDCopyCtor), "");
+  static_assert(!__is_trivially_move_constructible(NoDefaultMoveAssignDueToUDCopyCtor), "");
+
+  static_assert(__is_move_constructible(NonTCStruct), "");
+  static_assert(!__is_nothrow_move_constructible(NonTCStruct), "");
+  static_assert(!__is_trivially_move_constructible(NonTCStruct), "");
+
+  static_assert(__is_move_constructible(NonTrivialStruct), "");
+  static_assert(__is_nothrow_move_constructible(NonTrivialStruct), "");
+  static_assert(__is_trivially_move_constructible(NonTrivialStruct), "");
+
+  static_assert(__is_move_constructible(POD), "");
+  static_assert(__is_nothrow_move_constructible(POD), "");
+  static_assert(__is_trivially_move_constructible(POD), "");
+
+  static_assert(__is_move_constructible(SuperNonTrivialStruct), "");
+  static_assert(__is_nothrow_move_constructible(SuperNonTrivialStruct), "");
+  static_assert(!__is_trivially_move_constructible(SuperNonTrivialStruct), "");
+
+  static_assert(__is_move_constructible(TrivialStruct), "");
+  static_assert(__is_nothrow_move_constructible(TrivialStruct), "");
+  static_assert(__is_trivially_move_constructible(TrivialStruct), "");
+
+  static_assert(__is_move_constructible(Union), "");
+  static_assert(__is_nothrow_move_constructible(Union), "");
+  static_assert(__is_trivially_move_constructible(Union), "");
+
+  static_assert(__is_move_constructible(HasNothrowMoveCtor), "");
+  static_assert(__is_nothrow_move_constructible(HasNothrowMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(HasNothrowMoveCtor), "");
+
+  static_assert(__is_move_constructible(VolatileMoveCtor), "");
+  static_assert(!__is_nothrow_move_constructible(VolatileMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(VolatileMoveCtor), "");
+
+  static_assert(!__is_move_constructible(const VolatileMoveCtor), "");
+  static_assert(!__is_nothrow_move_constructible(const VolatileMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(const VolatileMoveCtor), "");
+
+  static_assert(__is_move_constructible(volatile VolatileMoveCtor), "");
+  static_assert(!__is_nothrow_move_constructible(volatile VolatileMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(volatile VolatileMoveCtor), "");
+
+  static_assert(!__is_move_constructible(const volatile VolatileMoveCtor), "");
+  static_assert(!__is_nothrow_move_constructible(const volatile VolatileMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(const volatile VolatileMoveCtor), "");
+
+  static_assert(!__is_move_constructible(AllDeleted), "");
+  static_assert(!__is_nothrow_move_constructible(AllDeleted), "");
+  static_assert(!__is_trivially_move_constructible(AllDeleted), "");
+
+  static_assert(!__is_move_constructible(AllPrivate), "");
+  static_assert(!__is_nothrow_move_constructible(AllPrivate), "");
+  static_assert(!__is_trivially_move_constructible(AllPrivate), "");
+
+  static_assert(!__is_move_constructible(AnIncompleteType[]), "");
+  static_assert(!__is_nothrow_move_constructible(AnIncompleteType[]), "");
+  static_assert(!__is_trivially_move_constructible(AnIncompleteType[]), "");
+
+  static_assert(!__is_move_constructible(AnIncompleteType), ""); // expected-error{{incomplete type}}
+  static_assert(!__is_nothrow_move_constructible(AnIncompleteType), ""); // expected-error{{incomplete type}}
+  static_assert(!__is_trivially_move_constructible(AnIncompleteType), ""); // expected-error{{incomplete type}}
+
+  static_assert(!__is_move_constructible(BaseDeletedCopyCtor), "");
+  static_assert(!__is_nothrow_move_constructible(BaseDeletedCopyCtor), "");
+  static_assert(!__is_trivially_move_constructible(BaseDeletedCopyCtor), "");
+
+  static_assert(!__is_move_constructible(BaseDeletedCopyCtor), "");
+  static_assert(!__is_nothrow_move_constructible(BaseDeletedCopyCtor), "");
+  static_assert(!__is_trivially_move_constructible(BaseDeletedCopyCtor), "");
+
+  static_assert(!__is_move_constructible(BaseDeletedMoveCtor), "");
+  static_assert(!__is_nothrow_move_constructible(BaseDeletedMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(BaseDeletedMoveCtor), "");
+
+  static_assert(!__is_move_constructible(CopyCtorDeleted), "");
+  static_assert(!__is_nothrow_move_constructible(CopyCtorDeleted), "");
+  static_assert(!__is_trivially_move_constructible(CopyCtorDeleted), "");
+
+  static_assert(!__is_move_constructible(CopyCtorDeleted), "");
+  static_assert(!__is_nothrow_move_constructible(CopyCtorDeleted), "");
+  static_assert(!__is_trivially_move_constructible(CopyCtorDeleted), "");
+
+  static_assert(!__is_move_constructible(CVCopyCtor), "");
+  static_assert(!__is_nothrow_move_constructible(CVCopyCtor), "");
+  static_assert(!__is_trivially_move_constructible(CVCopyCtor), "");
+
+  static_assert(!__is_move_constructible(HasMutableCopyCtor), "");
+  static_assert(!__is_nothrow_move_constructible(HasMutableCopyCtor), "");
+  static_assert(!__is_trivially_move_constructible(HasMutableCopyCtor), "");
+
+  static_assert(!__is_move_constructible(HasMoveAssign), "");
+  static_assert(!__is_nothrow_move_constructible(HasMoveAssign), "");
+  static_assert(!__is_trivially_move_constructible(HasMoveAssign), "");
+
+  static_assert(!__is_move_constructible(MemberDeletedCopyCtor), "");
+  static_assert(!__is_nothrow_move_constructible(MemberDeletedCopyCtor), "");
+  static_assert(!__is_trivially_move_constructible(MemberDeletedCopyCtor), "");
+
+  static_assert(!__is_move_constructible(MemberDeletedCopyCtor), "");
+  static_assert(!__is_nothrow_move_constructible(MemberDeletedCopyCtor), "");
+  static_assert(!__is_trivially_move_constructible(MemberDeletedCopyCtor), "");
+
+  static_assert(!__is_move_constructible(MemberDeletedMoveCtor), "");
+  static_assert(!__is_nothrow_move_constructible(MemberDeletedMoveCtor), "");
+  static_assert(!__is_trivially_move_constructible(MemberDeletedMoveCtor), "");
+
+  static_assert(!__is_move_constructible(MoveCtorDeleted), "");
+  static_assert(!__is_nothrow_move_constructible(MoveCtorDeleted), "");
+  static_assert(!__is_trivially_move_constructible(MoveCtorDeleted), "");
+
+  static_assert(!__is_move_constructible(VirtAr), "");
+  static_assert(!__is_nothrow_move_constructible(VirtAr), "");
+  static_assert(!__is_trivially_move_constructible(VirtAr), "");
+
+  static_assert(!__is_move_constructible(VolatileCopyCtor), "");
+  static_assert(!__is_nothrow_move_constructible(VolatileCopyCtor), "");
+  static_assert(!__is_trivially_move_constructible(VolatileCopyCtor), "");
+
+  // Non-referencable types
+  static_assert(!__is_move_constructible(void), "");
+  static_assert(!__is_nothrow_move_constructible(void), "");
+  static_assert(!__is_trivially_move_constructible(void), "");
+
+  static_assert(!__is_move_constructible(void()), "");
+  static_assert(!__is_nothrow_move_constructible(void()), "");
+  static_assert(!__is_trivially_move_constructible(void()), "");
+}
+
 struct MutableCopyAssign_QualNone {
   MutableCopyAssign_QualNone &operator=(MutableCopyAssign_QualNone &);
 };
 struct MutableCopyAssign_QualConst {
   MutableCopyAssign_QualConst &operator=(MutableCopyAssign_QualConst &) const;
 };
 struct MutableCopyAssign_QualVolatile {
   MutableCopyAssign_QualVolatile &operator=(MutableCopyAssign_QualVolatile &) volatile;