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

[cjdb]

Summary

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.

• __is_nullptr
• __is_bounded_array
• __is_scoped_enum
• __is_unbounded_array
• __is_copy_constructible
• __is_move_constructible
• __is_copy_assignable
• __is_move_assignable
• __is_referenceable

[cjdb]

rebases to activate CI

[cjdb]

adds __is_unbounded_array

[cjdb]

adds __is_copy_constructible, __is_copy_assignable, __is_move_constructible (WIP), and __is_move_assignable (incomplete)

[aaron.ballman]

clang/lib/Sema/SemaExprCXX.cpp

4905–4906

Is a VLA a bounded array? (We support those as an extension in C++, unfortunately.)

5304

Why this dance and not Self.LangOpts.CPlusPlus? (Same below.)

5311

It looks like this file could stand to be clang formatted.

clang/test/SemaCXX/type-traits.cpp

736

Please add a test for VLAs to whichever function it should be tested under.

763

Any reason there's not a test with something like int[10] and int[]? (Same below.)

[cjdb]

• finishes __is_move_constructible and __is_move_assignable
• fixes detecting C++ mode
• clang-formats

clang/lib/Sema/SemaExprCXX.cpp

4905–4906

__is_bounded_array(T) is true when "T is an array type of known bound". Do VLAs meet this criteria?

5311

Yeah, there was a time where arc diff did the formatting automatically, but it seems that day has passed :(

clang/test/SemaCXX/type-traits.cpp

763

Those are IntAr and IntArNB at the very top. I can rename those if you'd like.

[aaron.ballman]

clang/lib/Sema/SemaExprCXX.cpp

4905–4906

Heh, that's just it -- I don't know what constitutes "known". A VLA that tracks its extent "knows" the extent at runtime but possibly not compile time. So it's known-ish.

I think there's a few ways we could go about it.

1. all VLAs are unbounded because some VLAs may not have their size known until runtime
2. check the VLA's size expression and if we can find any way to constant evaluate it to a known value, then it's a bounded array
3. make it an error to call this function with a VLA

My intuition is that #3 is the safest approach, but that #1 probably is sufficiently defensible as well. I worry a little bit that #2 will give surprising results without more investigation/effort (we sometimes fold VLAs into constant arrays, and I think users would expect this API to mirror that behavior).

clang/test/SemaCXX/type-traits.cpp

763

Oh, yeah, I totally missed that, thank you!

Up to you on the rename, so long as we have the coverage, that's the crucial bit.

[cjdb]

clang/test/SemaCXX/type-traits.cpp

763

Would you be against a patch where I found and replaced all TypeAr with Type[2] and TypeArNB with Type[]? I've done several double takes myself and question the readability of TypeAr.

[aaron.ballman]

clang/test/SemaCXX/type-traits.cpp

763

I'd be fine with that -- it would be an easy NFC change after this lands.

[cjdb]

• handles VLAs
• adds __is_referenceable which is used by portions of the standard library

[cjdb]

fixes formatting

[aaron.ballman]

LGTM modulo whatever changes are needed based on feedback from the original review (I noticed Richard has some suggestions there which may impact this review).

[cjdb]

makes __is_destructible and __is_nothrow_destructible KEYCXX instead of KEYMS (attention @aaron.ballman)

[cjdb]

rebases for D116203's sake

[cjdb]

rebases

[cjdb]

I think this covers all the feedback @rsmith has provided, though my treatment of BuildPointerType and BuildReferenceType might be wrong.

Hopefully __make_signed and __make_unsigned are correct now!

[cjdb]

fixes commit update mistake and rebases to ToT

[cjdb]

changes RemoveReference to BuiltinRemoveReference

[cjdb]

This commit is suffering from feature creep, which has a whole host of problems associated with it. I'm going to dump everything that I've got related to the patch here for archival purposes, abandon it, and then spin out tiny CLs, some of which are hopefully trivial to review thanks to being early additions to this one.

[cjdb]

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

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_vla_decl_has_static_storage : Error<
   "variable length array declaration cannot have 'static' storage duration">;
 def err_vla_decl_has_extern_linkage : Error<
   "variable length array declaration cannot have 'extern' linkage">;
 def ext_vla_folded_to_constant : ExtWarn<
   "variable length array folded to constant array as an extension">,
   InGroup<GNUFoldingConstant>;
 def err_vla_unsupported : Error<
-  "variable length arrays are not supported for the current target">;
+  "variable length arrays are not supported for %select{the current target|'%1'}0">;
 def note_vla_unsupported : Note<
   "variable length arrays are not supported for the current target">;
 
 // C99 variably modified types
 def err_variably_modified_template_arg : Error<
   "variably modified type %0 cannot be used as a template argument">;
 def err_variably_modified_nontype_template_param : Error<
   "non-type template parameter of variably modified type %0">;

clang/include/clang/Basic/TokenKinds.def

 KEYWORD(__FUNCDNAME__               , KEYMS)
 KEYWORD(__FUNCSIG__                 , KEYMS)
 KEYWORD(L__FUNCTION__               , KEYMS)
 KEYWORD(L__FUNCSIG__                , KEYMS)
 TYPE_TRAIT_1(__is_interface_class, IsInterfaceClass, KEYMS)
 TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS)
 
 // MSVC12.0 / VS2013 Type Traits
-TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYMS)
+TYPE_TRAIT_1(__is_destructible, IsDestructible, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_destructible, IsTriviallyDestructible, KEYCXX)
-TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYMS)
+TYPE_TRAIT_1(__is_nothrow_destructible, IsNothrowDestructible, KEYCXX)
 TYPE_TRAIT_2(__is_nothrow_assignable, IsNothrowAssignable, KEYCXX)
 TYPE_TRAIT_N(__is_constructible, IsConstructible, KEYCXX)
 TYPE_TRAIT_N(__is_nothrow_constructible, IsNothrowConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_copy_constructible, IsCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_copy_assignable, IsCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_move_constructible, IsMoveConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_move_assignable, IsMoveAssignable, KEYCXX)
 
 // MSVC14.0 / VS2015 Type Traits
 TYPE_TRAIT_2(__is_assignable, IsAssignable, KEYCXX)
 
 // MSVC Type Traits of unknown vintage
 TYPE_TRAIT_1(__has_nothrow_move_assign, HasNothrowMoveAssign, KEYCXX)
 TYPE_TRAIT_1(__has_trivial_move_assign, HasTrivialMoveAssign, KEYCXX)
 TYPE_TRAIT_1(__has_trivial_move_constructor, HasTrivialMoveConstructor, KEYCXX)

 TYPE_TRAIT_1(__has_unique_object_representations,
              HasUniqueObjectRepresentations, KEYCXX)
 
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) KEYWORD(__##Trait, KEYCXX)
 #include "clang/Basic/TransformTypeTraits.def"
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
+TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
+TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)
+TYPE_TRAIT_1(__is_nullptr, IsNullPointer, KEYCXX)
+TYPE_TRAIT_1(__is_scoped_enum, IsScopedEnum, KEYCXX)
+TYPE_TRAIT_1(__is_referenceable, IsReferenceable, KEYCXX)
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // 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

 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) tok::kw___##Trait,
 #include "clang/Basic/TransformTypeTraits.def"
           tok::kw___is_abstract,
           tok::kw___is_aggregate,
           tok::kw___is_arithmetic,
           tok::kw___is_array,
           tok::kw___is_assignable,
           tok::kw___is_base_of,
+          tok::kw___is_bounded_array,
           tok::kw___is_class,
           tok::kw___is_complete_type,
           tok::kw___is_compound,
           tok::kw___is_const,
           tok::kw___is_constructible,
           tok::kw___is_convertible,
           tok::kw___is_convertible_to,
           tok::kw___is_destructible,
#include "clang/Basic/TransformTypeTraits.def"
           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_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_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
     // name of struct templates, but some are keywords in GCC >= 4.3
     // and Clang. Therefore, when we see the token sequence "struct
     // X", make X into a normal identifier rather than a keyword, to

clang/lib/Parse/ParseExpr.cpp

#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] \
             = RTT_JOIN(tok::kw_,Name)
 
           REVERTIBLE_TYPE_TRAIT(__is_abstract);
           REVERTIBLE_TYPE_TRAIT(__is_aggregate);
           REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
           REVERTIBLE_TYPE_TRAIT(__is_array);
           REVERTIBLE_TYPE_TRAIT(__is_assignable);
+          REVERTIBLE_TYPE_TRAIT(__is_bounded_array);
           REVERTIBLE_TYPE_TRAIT(__is_base_of);
           REVERTIBLE_TYPE_TRAIT(__is_class);
           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
           REVERTIBLE_TYPE_TRAIT(__is_compound);
           REVERTIBLE_TYPE_TRAIT(__is_const);
           REVERTIBLE_TYPE_TRAIT(__is_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_convertible);
           REVERTIBLE_TYPE_TRAIT(__is_convertible_to);
#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           REVERTIBLE_TYPE_TRAIT(__is_pod);
           REVERTIBLE_TYPE_TRAIT(__is_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_polymorphic);
           REVERTIBLE_TYPE_TRAIT(__is_reference);
           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_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)                                     \
   REVERTIBLE_TYPE_TRAIT(RTT_JOIN(__, Trait));
 #include "clang/Basic/TransformTypeTraits.def"
 #undef REVERTIBLE_TYPE_TRAIT

clang/lib/Sema/SemaExprCXX.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/AlignedAllocation.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TypeTraits.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
case UTT_IsCompleteType:
     // These traits are modeled on the type predicates in C++0x
     // [meta.unary.cat] and [meta.unary.comp]. They are not specified as
     // requiring a complete type, as whether or not they return true cannot be
     // impacted by the completeness of the type.
   case UTT_IsVoid:
   case UTT_IsIntegral:
   case UTT_IsFloatingPoint:
   case UTT_IsArray:
+  case UTT_IsBoundedArray:
   case UTT_IsPointer:
+  case UTT_IsNullPointer:
+  case UTT_IsReferenceable:
   case UTT_IsLvalueReference:
   case UTT_IsRvalueReference:
   case UTT_IsMemberFunctionPointer:
   case UTT_IsMemberObjectPointer:
   case UTT_IsEnum:
+  case UTT_IsScopedEnum:
   case UTT_IsUnion:
   case UTT_IsClass:
   case UTT_IsFunction:
   case UTT_IsReference:
   case UTT_IsArithmetic:
   case UTT_IsFundamental:
   case UTT_IsObject:
   case UTT_IsScalar:
   case UTT_IsCompound:
   case UTT_IsMemberPointer:
     // Fall-through
 
     // These traits are modeled on type predicates in C++0x [meta.unary.prop]
     // which requires some of its traits to have the complete type. However,
     // the completeness of the type cannot impact these traits' semantics, and
     // so they don't require it. This matches the comments on these traits in
     // Table 49.
   case UTT_IsConst:
   case UTT_IsVolatile:
   case UTT_IsSigned:
+  case UTT_IsUnboundedArray:
   case UTT_IsUnsigned:
 
   // This type trait always returns false, checking the type is moot.
   case UTT_IsInterfaceClass:
     return true;
 
   // C++14 [meta.unary.prop]:
   //   If T is a non-union class type, T shall be a complete type.
case UTT_HasVirtualDestructor:
     [[fallthrough]];
 
   // C++1z [meta.unary.prop]:
   //   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_IsCopyAssignable:
+  case UTT_IsMoveConstructible:
+  case UTT_IsMoveAssignable:
     if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
       return true;
 
     return !S.RequireCompleteType(
         Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
   }
 }
 
for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end();
           return false;
       }
     }
     return FoundOperator;
   }
   return false;
 }
 
+static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
+                              ArrayRef<TypeSourceInfo *> Args,
+                              SourceLocation RParenLoc);
+static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
+                                    QualType RhsT, SourceLocation KeyLoc);
+
 static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
                                    SourceLocation KeyLoc, QualType T) {
   assert(!T->isDependentType() && "Cannot evaluate traits of dependent type");
 
   ASTContext &C = Self.Context;
   switch(UTT) {
   default: llvm_unreachable("not a UTT");
     // Type trait expressions corresponding to the primary type category
     // predicates in C++0x [meta.unary.cat].
   case UTT_IsVoid:
     return T->isVoidType();
   case UTT_IsIntegral:
     return T->isIntegralType(C);
   case UTT_IsFloatingPoint:
     return T->isFloatingType();
   case UTT_IsArray:
     return T->isArrayType();
+  case UTT_IsBoundedArray:
+    if (T->isVariableArrayType())
+      Self.Diag(KeyLoc, diag::err_vla_unsupported)
+          << 1 << tok::kw___is_bounded_array;
+    return T->isArrayType() && !T->isIncompleteArrayType();
+  case UTT_IsUnboundedArray:
+    if (T->isVariableArrayType())
+      Self.Diag(KeyLoc, diag::err_vla_unsupported)
+          << 1 << tok::kw___is_unbounded_array;
+    return T->isIncompleteArrayType();
   case UTT_IsPointer:
     return T->isAnyPointerType();
+  case UTT_IsNullPointer:
+    return T->isNullPtrType();
   case UTT_IsLvalueReference:
     return T->isLValueReferenceType();
   case UTT_IsRvalueReference:
     return T->isRValueReferenceType();
   case UTT_IsMemberFunctionPointer:
     return T->isMemberFunctionPointerType();
   case UTT_IsMemberObjectPointer:
     return T->isMemberDataPointerType();
   case UTT_IsEnum:
     return T->isEnumeralType();
+  case UTT_IsScopedEnum:
+    return T->isScopedEnumeralType();
   case UTT_IsUnion:
     return T->isUnionType();
   case UTT_IsClass:
     return T->isClassType() || T->isStructureType() || T->isInterfaceType();
   case UTT_IsFunction:
     return T->isFunctionType();
 
     // Type trait expressions which correspond to the convenient composition
case UTT_IsCompleteType:
     // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
     //   Returns True if and only if T is a complete type at the point of the
     //   function call.
     return !T->isIncompleteType();
   case UTT_HasUniqueObjectRepresentations:
     return C.hasUniqueObjectRepresentations(T);
   case UTT_IsTriviallyRelocatable:
     return T.isTriviallyRelocatableType(C);
+  case UTT_IsCopyConstructible:
+  case UTT_IsCopyAssignable: {
+    if (T->isIncompleteArrayType())
+      return false;
+    if (!T.isReferenceable())
+      return false;
+
+    QualType AssigneeType = Self.BuiltinRemoveReference(T, UnaryTransformType::RemoveCVRef, {});
+    AssigneeType.addConst();
+    AssigneeType = Self.BuildReferenceType(AssigneeType, true, KeyLoc,
+                                           T.getBaseTypeIdentifier());
+    if (UTT == UTT_IsCopyAssignable) {
+      return EvaluateBinaryTypeTrait(
+          Self, BTT_IsAssignable,
+          Self.BuildReferenceType(T, true, KeyLoc, T.getBaseTypeIdentifier()),
+          AssigneeType, KeyLoc);
+    }
+    llvm::SmallVector<TypeSourceInfo *, 2> Parameters = {
+        C.CreateTypeSourceInfo(T), C.CreateTypeSourceInfo(AssigneeType)};
+    return evaluateTypeTrait(Self, TT_IsConstructible, KeyLoc, Parameters, {});
+  }
+  case UTT_IsMoveConstructible:
+  case UTT_IsMoveAssignable: {
+    if (T->isIncompleteArrayType())
+      return false;
+    if (!T.isReferenceable())
+      return false;
+
+    QualType AssigneeType = Self.BuiltinRemoveReference(T, UnaryTransformType::RemoveCVRef, {});
+    AssigneeType = Self.BuildReferenceType(AssigneeType, false, KeyLoc,
+                                           T.getBaseTypeIdentifier());
+    if (UTT == UTT_IsMoveAssignable)
+      return EvaluateBinaryTypeTrait(
+          Self, BTT_IsAssignable,
+          Self.BuildReferenceType(T, true, KeyLoc, T.getBaseTypeIdentifier()),
+          AssigneeType, KeyLoc);
+    llvm::SmallVector<TypeSourceInfo *, 2> Parameters = {
+        C.CreateTypeSourceInfo(T), C.CreateTypeSourceInfo(AssigneeType)};
+    return evaluateTypeTrait(Self, TT_IsConstructible, KeyLoc, Parameters, {});
+  }
+  case UTT_IsReferenceable:
+    return T.isReferenceable();
   }
 }
-
-static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
-                                    QualType RhsT, SourceLocation KeyLoc);
 
 static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
                               ArrayRef<TypeSourceInfo *> Args,
                               SourceLocation RParenLoc) {
   if (Kind <= UTT_Last)
     return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
 
   // Evaluate BTT_ReferenceBindsToTemporary alongside the IsConstructible

clang/lib/Sema/SemaType.cpp

if (!R.isUsable()) {
       }
 
       T = Context.getConstantArrayType(T, ConstVal, ArraySize, ASM, Quals);
     }
   }
 
   if (T->isVariableArrayType() && !Context.getTargetInfo().isVLASupported()) {
     // CUDA device code and some other targets don't support VLAs.
-    targetDiag(Loc, (getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
-                        ? diag::err_cuda_vla
-                        : diag::err_vla_unsupported)
-        << ((getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
-                ? CurrentCUDATarget()
-                : CFT_InvalidTarget);
+    bool IsCUDADevice = (getLangOpts().CUDA && getLangOpts().CUDAIsDevice);
+    targetDiag(Loc,
+               IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported)
+        << (IsCUDADevice ? CurrentCUDATarget() : 0);
   }
 
   // If this is not C99, diagnose array size modifiers on non-VLAs.
   if (!getLangOpts().C99 && !T->isVariableArrayType() &&
       (ASM != ArrayType::Normal || Quals != 0)) {
     Diag(Loc, getLangOpts().CPlusPlus ? diag::err_c99_array_usage_cxx
                                       : diag::ext_c99_array_usage)
         << ASM;

clang/test/SemaCXX/type-traits.cpp

void is_union()
   { int arr[F(__is_union(IntAr))]; }
   { int arr[F(__is_union(UnionAr))]; }
   { int arr[F(__is_union(cvoid))]; }
   { int arr[F(__is_union(IntArNB))]; }
   { int arr[F(__is_union(HasAnonymousUnion))]; }
 }
 
 typedef Enum EnumType;
+typedef EnumClass EnumClassType;
 
 void is_enum()
 {
   { int arr[T(__is_enum(Enum))]; }
   { int arr[T(__is_enum(EnumType))]; }
+  { int arr[T(__is_enum(SignedEnum))]; }
+  { int arr[T(__is_enum(UnsignedEnum))]; }
+
+  { int arr[T(__is_enum(EnumClass))]; }
+  { int arr[T(__is_enum(EnumClassType))]; }
+  { int arr[T(__is_enum(SignedEnumClass))]; }
+  { int arr[T(__is_enum(UnsignedEnumClass))]; }
 
   { int arr[F(__is_enum(int))]; }
   { int arr[F(__is_enum(Union))]; }
   { int arr[F(__is_enum(Int))]; }
   { int arr[F(__is_enum(IntAr))]; }
   { int arr[F(__is_enum(UnionAr))]; }
   { int arr[F(__is_enum(Derives))]; }
   { int arr[F(__is_enum(ClassType))]; }
   { int arr[F(__is_enum(cvoid))]; }
   { int arr[F(__is_enum(IntArNB))]; }
   { int arr[F(__is_enum(HasAnonymousUnion))]; }
 }
 
+void is_scoped_enum() {
+  { int arr[F(__is_scoped_enum(Enum))]; }
+  { int arr[F(__is_scoped_enum(EnumType))]; }
+  { int arr[F(__is_scoped_enum(SignedEnum))]; }
+  { int arr[F(__is_scoped_enum(UnsignedEnum))]; }
+
+  { int arr[T(__is_scoped_enum(EnumClass))]; }
+  { int arr[T(__is_scoped_enum(EnumClassType))]; }
+  { int arr[T(__is_scoped_enum(SignedEnumClass))]; }
+  { int arr[T(__is_scoped_enum(UnsignedEnumClass))]; }
+
+  { int arr[F(__is_scoped_enum(int))]; }
+  { int arr[F(__is_scoped_enum(Union))]; }
+  { int arr[F(__is_scoped_enum(Int))]; }
+  { int arr[F(__is_scoped_enum(IntAr))]; }
+  { int arr[F(__is_scoped_enum(UnionAr))]; }
+  { int arr[F(__is_scoped_enum(Derives))]; }
+  { int arr[F(__is_scoped_enum(ClassType))]; }
+  { int arr[F(__is_scoped_enum(cvoid))]; }
+  { int arr[F(__is_scoped_enum(IntArNB))]; }
+  { int arr[F(__is_scoped_enum(HasAnonymousUnion))]; }
+}
+
 struct FinalClass final {
 };
 
 template<typename T>
 struct PotentiallyFinal { };
 
 template<typename T>
 struct PotentiallyFinal<T*> final { };
void is_array()
   int t26[F(__is_array(Union))];
   int t27[F(__is_array(Derives))];
   int t28[F(__is_array(ClassType))];
   int t29[F(__is_array(Enum))];
   int t30[F(__is_array(void*))];
   int t31[F(__is_array(cvoid*))];
 }
 
+void is_bounded_array(int n) {
+  int t01[T(__is_bounded_array(IntAr))];
+  int t02[F(__is_bounded_array(IntArNB))];
+  int t03[T(__is_bounded_array(UnionAr))];
+
+  int t10[F(__is_bounded_array(void))];
+  int t11[F(__is_bounded_array(cvoid))];
+  int t12[F(__is_bounded_array(float))];
+  int t13[F(__is_bounded_array(double))];
+  int t14[F(__is_bounded_array(long double))];
+  int t15[F(__is_bounded_array(bool))];
+  int t16[F(__is_bounded_array(char))];
+  int t17[F(__is_bounded_array(signed char))];
+  int t18[F(__is_bounded_array(unsigned char))];
+  int t19[F(__is_bounded_array(wchar_t))];
+  int t20[F(__is_bounded_array(short))];
+  int t21[F(__is_bounded_array(unsigned short))];
+  int t22[F(__is_bounded_array(int))];
+  int t23[F(__is_bounded_array(unsigned int))];
+  int t24[F(__is_bounded_array(long))];
+  int t25[F(__is_bounded_array(unsigned long))];
+  int t26[F(__is_bounded_array(Union))];
+  int t27[F(__is_bounded_array(Derives))];
+  int t28[F(__is_bounded_array(ClassType))];
+  int t29[F(__is_bounded_array(Enum))];
+  int t30[F(__is_bounded_array(void *))];
+  int t31[F(__is_bounded_array(cvoid *))];
+
+  int t32[n];
+  (void)__is_bounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported for '__is_bounded_array'}}
+}
+
+void is_unbounded_array(int n) {
+  int t01[F(__is_unbounded_array(IntAr))];
+  int t02[T(__is_unbounded_array(IntArNB))];
+  int t03[F(__is_unbounded_array(UnionAr))];
+
+  int t10[F(__is_unbounded_array(void))];
+  int t11[F(__is_unbounded_array(cvoid))];
+  int t12[F(__is_unbounded_array(float))];
+  int t13[F(__is_unbounded_array(double))];
+  int t14[F(__is_unbounded_array(long double))];
+  int t15[F(__is_unbounded_array(bool))];
+  int t16[F(__is_unbounded_array(char))];
+  int t17[F(__is_unbounded_array(signed char))];
+  int t18[F(__is_unbounded_array(unsigned char))];
+  int t19[F(__is_unbounded_array(wchar_t))];
+  int t20[F(__is_unbounded_array(short))];
+  int t21[F(__is_unbounded_array(unsigned short))];
+  int t22[F(__is_unbounded_array(int))];
+  int t23[F(__is_unbounded_array(unsigned int))];
+  int t24[F(__is_unbounded_array(long))];
+  int t25[F(__is_unbounded_array(unsigned long))];
+  int t26[F(__is_unbounded_array(Union))];
+  int t27[F(__is_unbounded_array(Derives))];
+  int t28[F(__is_unbounded_array(ClassType))];
+  int t29[F(__is_unbounded_array(Enum))];
+  int t30[F(__is_unbounded_array(void *))];
+  int t31[F(__is_unbounded_array(cvoid *))];
+
+  int t32[n];
+  (void)__is_unbounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported for '__is_unbounded_array'}}
+}
+
+void is_referenceable() {
+  { int a[T(__is_referenceable(int))]; }
+  { int a[T(__is_referenceable(const int))]; }
+  { int a[T(__is_referenceable(volatile int))]; }
+  { int a[T(__is_referenceable(const volatile int))]; }
+  { int a[T(__is_referenceable(int *))]; }
+  { int a[T(__is_referenceable(int &))]; }
+  { int a[T(__is_referenceable(int &&))]; }
+  { int a[T(__is_referenceable(int (*)()))]; }
+  { int a[T(__is_referenceable(int (&)()))]; }
+  { int a[T(__is_referenceable(int(&&)()))]; }
+  { int a[T(__is_referenceable(IntAr))]; }
+  { int a[T(__is_referenceable(IntArNB))]; }
+  { int a[T(__is_referenceable(decltype(nullptr)))]; }
+  { int a[T(__is_referenceable(Empty))]; }
+  { int a[T(__is_referenceable(Union))]; }
+  { int a[T(__is_referenceable(Derives))]; }
+  { int a[T(__is_referenceable(Enum))]; }
+  { int a[T(__is_referenceable(EnumClass))]; }
+  { int a[T(__is_referenceable(int Empty::*))]; }
+  { int a[T(__is_referenceable(int(Empty::*)()))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() volatile))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const volatile))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() &))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const &))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() volatile &))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const volatile &))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() &&))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const &&))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() volatile &&))]; }
+  { int a[T(__is_referenceable(int(Empty::*)() const volatile &&))]; }
+
+  { int a[F(__is_referenceable(void))]; }
+}
+
 template <typename T> void tmpl_func(T&) {}
 
 template <typename T> struct type_wrapper {
   typedef T type;
   typedef T* ptrtype;
   typedef T& reftype;
 };
 
void is_pointer()
   int t29[F(__is_pointer(IntArNB))];
   int t30[F(__is_pointer(Union))];
   int t31[F(__is_pointer(UnionAr))];
   int t32[F(__is_pointer(StructWithMembers))];
   int t33[F(__is_pointer(int StructWithMembers::*))];
   int t34[F(__is_pointer(void (StructWithMembers::*) ()))];
 }
 
+void is_null_pointer() {
+  StructWithMembers x;
+
+  int t00[T(__is_nullptr(decltype(nullptr)))];
+  int t01[F(__is_nullptr(void *))];
+  int t02[F(__is_nullptr(cvoid *))];
+  int t03[F(__is_nullptr(cvoid *))];
+  int t04[F(__is_nullptr(char *))];
+  int t05[F(__is_nullptr(int *))];
+  int t06[F(__is_nullptr(int **))];
+  int t07[F(__is_nullptr(ClassType *))];
+  int t08[F(__is_nullptr(Derives *))];
+  int t09[F(__is_nullptr(Enum *))];
+  int t10[F(__is_nullptr(IntArNB *))];
+  int t11[F(__is_nullptr(Union *))];
+  int t12[F(__is_nullptr(UnionAr *))];
+  int t13[F(__is_nullptr(StructWithMembers *))];
+  int t14[F(__is_nullptr(void (*)()))];
+
+  int t20[F(__is_nullptr(void))];
+  int t21[F(__is_nullptr(cvoid))];
+  int t22[F(__is_nullptr(cvoid))];
+  int t23[F(__is_nullptr(char))];
+  int t24[F(__is_nullptr(int))];
+  int t25[F(__is_nullptr(int))];
+  int t26[F(__is_nullptr(ClassType))];
+  int t27[F(__is_nullptr(Derives))];
+  int t28[F(__is_nullptr(Enum))];
+  int t29[F(__is_nullptr(IntArNB))];
+  int t30[F(__is_nullptr(Union))];
+  int t31[F(__is_nullptr(UnionAr))];
+  int t32[F(__is_nullptr(StructWithMembers))];
+  int t33[F(__is_nullptr(int StructWithMembers::*))];
+  int t34[F(__is_nullptr(void(StructWithMembers::*)()))];
+}
+
 void is_member_object_pointer()
 {
   StructWithMembers x;
 
   int t01[T(__is_member_object_pointer(int StructWithMembers::*))];
 
   int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))];
   int t11[F(__is_member_object_pointer(void*))];
void is_unsigned()
   int t28[F(__is_unsigned(UnsignedEnum))];
   int t29[F(__is_unsigned(SignedEnum))];
 }
 
 typedef Int& IntRef;
 typedef const IntAr ConstIntAr;
 typedef ConstIntAr ConstIntArAr[4];
 
-struct HasCopy {
-  HasCopy(HasCopy& cp);
+struct HasMutableCopyCtor {
+  HasMutableCopyCtor(HasMutableCopyCtor &cp);
 };
 
 struct HasMove {
   HasMove(HasMove&& cp);
 };
 
 struct HasTemplateCons {
   HasVirt Annoying;
void has_trivial_default_constructor() {
   { int arr[T(__has_trivial_constructor(const Int))]; }
   { int arr[T(__has_trivial_constructor(AllDefaulted))]; }
   { int arr[T(__has_trivial_constructor(AllDeleted))]; }
   { int arr[T(__has_trivial_constructor(ACompleteType[]))]; }
 
   { int arr[F(__has_trivial_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
   { int arr[F(__has_trivial_constructor(HasCons))]; }
   { int arr[F(__has_trivial_constructor(HasRef))]; }
-  { int arr[F(__has_trivial_constructor(HasCopy))]; }
+  { int arr[F(__has_trivial_constructor(HasMutableCopyCtor))]; }
   { int arr[F(__has_trivial_constructor(IntRef))]; }
   { int arr[F(__has_trivial_constructor(VirtAr))]; }
   { int arr[F(__has_trivial_constructor(void))]; }
   { int arr[F(__has_trivial_constructor(cvoid))]; }
   { int arr[F(__has_trivial_constructor(HasTemplateCons))]; }
   { int arr[F(__has_trivial_constructor(AllPrivate))]; }
   { int arr[F(__has_trivial_constructor(ExtDefaulted))]; }
 }
void has_trivial_copy_constructor() {
   { int arr[T(__has_trivial_copy(const Int))]; }
   { int arr[T(__has_trivial_copy(AllDefaulted))]; }
   { int arr[T(__has_trivial_copy(AllDeleted))]; }
   { int arr[T(__has_trivial_copy(DerivesAr))]; }
   { int arr[T(__has_trivial_copy(DerivesHasRef))]; }
   { int arr[T(__has_trivial_copy(ACompleteType[]))]; }
 
   { int arr[F(__has_trivial_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
-  { int arr[F(__has_trivial_copy(HasCopy))]; }
+  { int arr[F(__has_trivial_copy(HasMutableCopyCtor))]; }
   { int arr[F(__has_trivial_copy(HasTemplateCons))]; }
   { int arr[F(__has_trivial_copy(VirtAr))]; }
   { int arr[F(__has_trivial_copy(void))]; }
   { int arr[F(__has_trivial_copy(cvoid))]; }
   { int arr[F(__has_trivial_copy(AllPrivate))]; }
   { int arr[F(__has_trivial_copy(ExtDefaulted))]; }
 }
 
 void has_trivial_copy_assignment() {
   { int arr[T(__has_trivial_assign(Int))]; }
   { int arr[T(__has_trivial_assign(IntAr))]; }
   { int arr[T(__has_trivial_assign(Union))]; }
   { int arr[T(__has_trivial_assign(UnionAr))]; }
   { int arr[T(__has_trivial_assign(POD))]; }
   { int arr[T(__has_trivial_assign(Derives))]; }
   { int arr[T(__has_trivial_assign(HasDest))]; }
   { int arr[T(__has_trivial_assign(HasPriv))]; }
   { int arr[T(__has_trivial_assign(HasCons))]; }
   { int arr[T(__has_trivial_assign(HasRef))]; }
-  { int arr[T(__has_trivial_assign(HasCopy))]; }
+  { int arr[T(__has_trivial_assign(HasMutableCopyCtor))]; }
   { int arr[T(__has_trivial_assign(HasMove))]; }
   { int arr[T(__has_trivial_assign(HasMoveAssign))]; }
   { int arr[T(__has_trivial_assign(AllDefaulted))]; }
   { int arr[T(__has_trivial_assign(AllDeleted))]; }
   { int arr[T(__has_trivial_assign(DerivesAr))]; }
   { int arr[T(__has_trivial_assign(DerivesHasRef))]; }
   { int arr[T(__has_trivial_assign(ACompleteType[]))]; }
 
void has_trivial_destructor() {
   { int arr[T(__has_trivial_destructor(UnionAr))]; }
   { int arr[T(__has_trivial_destructor(POD))]; }
   { int arr[T(__has_trivial_destructor(Derives))]; }
   { int arr[T(__has_trivial_destructor(ConstIntAr))]; }
   { int arr[T(__has_trivial_destructor(ConstIntArAr))]; }
   { int arr[T(__has_trivial_destructor(HasPriv))]; }
   { int arr[T(__has_trivial_destructor(HasCons))]; }
   { int arr[T(__has_trivial_destructor(HasRef))]; }
-  { int arr[T(__has_trivial_destructor(HasCopy))]; }
+  { int arr[T(__has_trivial_destructor(HasMutableCopyCtor))]; }
   { int arr[T(__has_trivial_destructor(HasMove))]; }
   { int arr[T(__has_trivial_destructor(IntRef))]; }
   { int arr[T(__has_trivial_destructor(HasCopyAssign))]; }
   { int arr[T(__has_trivial_destructor(HasMoveAssign))]; }
   { int arr[T(__has_trivial_destructor(const Int))]; }
   { int arr[T(__has_trivial_destructor(DerivesAr))]; }
   { int arr[T(__has_trivial_destructor(VirtAr))]; }
   { int arr[T(__has_trivial_destructor(AllDefaulted))]; }
void has_nothrow_assign() {
   { int arr[T(__has_nothrow_assign(Union))]; }
   { int arr[T(__has_nothrow_assign(UnionAr))]; }
   { int arr[T(__has_nothrow_assign(POD))]; }
   { int arr[T(__has_nothrow_assign(Derives))]; }
   { int arr[T(__has_nothrow_assign(HasDest))]; }
   { int arr[T(__has_nothrow_assign(HasPriv))]; }
   { int arr[T(__has_nothrow_assign(HasCons))]; }
   { int arr[T(__has_nothrow_assign(HasRef))]; }
-  { int arr[T(__has_nothrow_assign(HasCopy))]; }
+  { int arr[T(__has_nothrow_assign(HasMutableCopyCtor))]; }
   { int arr[T(__has_nothrow_assign(HasMove))]; }
   { int arr[T(__has_nothrow_assign(HasMoveAssign))]; }
   { int arr[T(__has_nothrow_assign(HasNoThrowCopyAssign))]; }
   { int arr[T(__has_nothrow_assign(HasMultipleNoThrowCopyAssign))]; }
   { int arr[T(__has_nothrow_assign(HasVirtDest))]; }
   { int arr[T(__has_nothrow_assign(AllPrivate))]; }
   { int arr[T(__has_nothrow_assign(UsingAssign))]; }
   { int arr[T(__has_nothrow_assign(DerivesAr))]; }
void has_nothrow_copy() {
   { int arr[T(__has_nothrow_copy(HasMultipleNoThrowCopy))]; }
   { int arr[T(__has_nothrow_copy(HasVirtDest))]; }
   { int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
   { int arr[T(__has_nothrow_copy(AllPrivate))]; }
   { int arr[T(__has_nothrow_copy(DerivesAr))]; }
   { int arr[T(__has_nothrow_copy(ACompleteType[]))]; }
 
   { int arr[F(__has_nothrow_copy(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
-  { int arr[F(__has_nothrow_copy(HasCopy))]; }
+  { int arr[F(__has_nothrow_copy(HasMutableCopyCtor))]; }
   { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
   { int arr[F(__has_nothrow_copy(VirtAr))]; }
   { int arr[F(__has_nothrow_copy(void))]; }
   { int arr[F(__has_nothrow_copy(cvoid))]; }
 }
 
 void has_nothrow_constructor() {
   { int arr[T(__has_nothrow_constructor(Int))]; }
void has_nothrow_constructor() {
   { int arr[T(__has_nothrow_constructor(HasVirtDest))]; }
   // { int arr[T(__has_nothrow_constructor(VirtAr))]; } // not implemented
   { int arr[T(__has_nothrow_constructor(AllPrivate))]; }
   { int arr[T(__has_nothrow_constructor(ACompleteType[]))]; }
 
   { int arr[F(__has_nothrow_constructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
   { int arr[F(__has_nothrow_constructor(HasCons))]; }
   { int arr[F(__has_nothrow_constructor(HasRef))]; }
-  { int arr[F(__has_nothrow_constructor(HasCopy))]; }
+  { int arr[F(__has_nothrow_constructor(HasMutableCopyCtor))]; }
   { int arr[F(__has_nothrow_constructor(HasMove))]; }
   { int arr[F(__has_nothrow_constructor(HasNoThrowConstructorWithArgs))]; }
   { int arr[F(__has_nothrow_constructor(IntRef))]; }
   { int arr[F(__has_nothrow_constructor(void))]; }
   { int arr[F(__has_nothrow_constructor(cvoid))]; }
   { int arr[F(__has_nothrow_constructor(HasTemplateCons))]; }
 
   { int arr[F(__has_nothrow_constructor(HasMultipleDefaultConstructor1))]; }
void has_virtual_destructor() {
   { int arr[F(__has_virtual_destructor(DerivesAr))]; }
   { int arr[F(__has_virtual_destructor(const Int))]; }
   { int arr[F(__has_virtual_destructor(ConstIntAr))]; }
   { int arr[F(__has_virtual_destructor(ConstIntArAr))]; }
   { int arr[F(__has_virtual_destructor(HasDest))]; }
   { int arr[F(__has_virtual_destructor(HasPriv))]; }
   { int arr[F(__has_virtual_destructor(HasCons))]; }
   { int arr[F(__has_virtual_destructor(HasRef))]; }
-  { int arr[F(__has_virtual_destructor(HasCopy))]; }
+  { int arr[F(__has_virtual_destructor(HasMutableCopyCtor))]; }
   { int arr[F(__has_virtual_destructor(HasMove))]; }
   { int arr[F(__has_virtual_destructor(HasCopyAssign))]; }
   { int arr[F(__has_virtual_destructor(HasMoveAssign))]; }
   { int arr[F(__has_virtual_destructor(IntRef))]; }
   { int arr[F(__has_virtual_destructor(VirtAr))]; }
   { int arr[F(__has_virtual_destructor(ACompleteType[]))]; }
 
   { int arr[F(__has_virtual_destructor(AnIncompleteType[]))]; } // expected-error {{incomplete type}}
void constructible_checks() {
   { int arr[F(__is_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
   { int arr[F(__is_nothrow_constructible(AnIncompleteType[1]))]; } // expected-error {{incomplete type}}
   { int arr[F(__is_constructible(void))]; }
   { int arr[F(__is_nothrow_constructible(void))]; }
   { int arr[F(__is_constructible(const volatile void))]; }
   { int arr[F(__is_nothrow_constructible(const volatile void))]; }
 }
 
+struct VolatileCopyCtor {
+  VolatileCopyCtor(volatile VolatileCopyCtor &);
+};
+
+struct CVCopyCtor {
+  CVCopyCtor(const volatile CVCopyCtor &);
+};
+
+struct CopyCtorDeleted {
+  CopyCtorDeleted(const CopyCtorDeleted &) = delete;
+};
+
+struct BaseDeletedCopyCtor : CopyCtorDeleted {};
+
+struct MemberDeletedCopyCtor {
+  CopyCtorDeleted x;
+};
+
+template <bool expected, typename T>
+void copy_constructible_checks_impl() {
+  { int arr[T(__is_copy_constructible(T) == expected)]; }                // expected-error{{incomplete type}}
+  { int arr[T(__is_copy_constructible(const T) == expected)]; }          // expected-error{{incomplete type}}
+  { int arr[T(__is_copy_constructible(volatile T) == expected)]; }       // expected-error{{incomplete type}}
+  { int arr[T(__is_copy_constructible(const volatile T) == expected)]; } // expected-error{{incomplete type}}
+}
+
+void copy_constructible_checks() {
+  // Builtin types
+  copy_constructible_checks_impl<true, int>();
+  copy_constructible_checks_impl<false, int &>();
+  copy_constructible_checks_impl<false, int &&>();
+  copy_constructible_checks_impl<true, int *>();
+  copy_constructible_checks_impl<false, int[5]>();
+  copy_constructible_checks_impl<false, int[]>();
+  copy_constructible_checks_impl<true, decltype(nullptr)>();
+  copy_constructible_checks_impl<true, void (*)()>();
+  copy_constructible_checks_impl<false, void (&)()>();
+  copy_constructible_checks_impl<true, int Empty::*>();
+  copy_constructible_checks_impl<true, int (Empty::*)()>();
+  copy_constructible_checks_impl<true, int (Empty::*)() const>();
+  copy_constructible_checks_impl<true, int (Empty::*)() volatile>();
+  copy_constructible_checks_impl<true, int (Empty::*)() const volatile>();
+  copy_constructible_checks_impl<true, int (Empty::*)() &>();
+  copy_constructible_checks_impl<true, int (Empty::*)() const &>();
+  copy_constructible_checks_impl<true, int (Empty::*)() volatile &>();
+  copy_constructible_checks_impl<true, int (Empty::*)() const volatile &>();
+  copy_constructible_checks_impl<true, int (Empty::*)() &&>();
+  copy_constructible_checks_impl<true, int (Empty::*)() const &&>();
+  copy_constructible_checks_impl<true, int (Empty::*)() volatile &&>();
+  copy_constructible_checks_impl<true, int (Empty::*)() const volatile &&>();
+
+  // // User-defined types
+  copy_constructible_checks_impl<true, AllDefaulted>();
+  copy_constructible_checks_impl<true, AllDefaulted>();
+  copy_constructible_checks_impl<true, CEmptyStruct>();
+  copy_constructible_checks_impl<true, CppEmptyStruct>();
+  copy_constructible_checks_impl<true, CppStructNonStandardBy2ndVirtBase>();
+  copy_constructible_checks_impl<true, CppStructNonStandardByBase>();
+  copy_constructible_checks_impl<true, CppStructNonStandardByMemb>();
+  copy_constructible_checks_impl<true, CppStructNonStandardByProt>();
+  copy_constructible_checks_impl<true, CppStructNonStandardBySameBase>();
+  copy_constructible_checks_impl<true, CppStructNonStandardByVirt>();
+  copy_constructible_checks_impl<true, CppStructNonStandardByVirtBase>();
+  copy_constructible_checks_impl<true, CppStructStandard>();
+  copy_constructible_checks_impl<true, CStruct>();
+  copy_constructible_checks_impl<true, CVCopyCtor>();
+  copy_constructible_checks_impl<true, Derives>();
+  copy_constructible_checks_impl<true, DerivesHasRef>();
+  copy_constructible_checks_impl<true, Empty>();
+  copy_constructible_checks_impl<true, EmptyUnion>();
+  copy_constructible_checks_impl<true, Enum>();
+  copy_constructible_checks_impl<true, EnumClass>();
+  copy_constructible_checks_impl<true, ExtDefaulted>();
+  copy_constructible_checks_impl<true, ExtDefaulted>();
+  copy_constructible_checks_impl<true, HasCons>();
+  copy_constructible_checks_impl<true, HasCopyAssign>();
+  copy_constructible_checks_impl<true, HasDest>();
+  copy_constructible_checks_impl<true, HasMultipleCopy>();
+  copy_constructible_checks_impl<true, HasPriv>();
+  copy_constructible_checks_impl<true, HasRef>();
+  copy_constructible_checks_impl<true, HasTemplateCons>();
+  copy_constructible_checks_impl<true, NoDefaultMoveAssignDueToDtor>();
+  copy_constructible_checks_impl<true, NoDefaultMoveAssignDueToUDCopyAssign>();
+  copy_constructible_checks_impl<true, NoDefaultMoveAssignDueToUDCopyCtor>();
+  copy_constructible_checks_impl<true, NonTCStruct>();
+  copy_constructible_checks_impl<true, NonTrivialStruct>();
+  copy_constructible_checks_impl<true, POD>();
+  copy_constructible_checks_impl<true, SuperNonTrivialStruct>();
+  copy_constructible_checks_impl<true, TrivialStruct>();
+  copy_constructible_checks_impl<true, Union>();
+
+  copy_constructible_checks_impl<false, AllDeleted>();
+  copy_constructible_checks_impl<false, AllPrivate>();
+  copy_constructible_checks_impl<false, AnIncompleteType[]>();
+  copy_constructible_checks_impl<false, AnIncompleteType>(); // expected-note{{in instantiation of function template specialization}}
+  copy_constructible_checks_impl<false, BaseDeletedCopyCtor>();
+  copy_constructible_checks_impl<false, CopyCtorDeleted>();
+  copy_constructible_checks_impl<false, HasMutableCopyCtor>();
+  copy_constructible_checks_impl<false, HasMove>();
+  copy_constructible_checks_impl<false, HasMoveAssign>();
+  copy_constructible_checks_impl<false, MemberDeletedCopyCtor>();
+  copy_constructible_checks_impl<false, VirtAr>();
+  copy_constructible_checks_impl<false, VolatileCopyCtor>();
+
+  // Non-referencable types
+  copy_constructible_checks_impl<false, void>();
+  copy_constructible_checks_impl<false, void()>();
+  copy_constructible_checks_impl<false, void() const>();
+  copy_constructible_checks_impl<false, void() volatile>();
+  copy_constructible_checks_impl<false, void() const volatile>();
+  copy_constructible_checks_impl<false, void() &>();
+  copy_constructible_checks_impl<false, void() const &>();
+  copy_constructible_checks_impl<false, void() volatile &>();
+  copy_constructible_checks_impl<false, void() const volatile &>();
+  copy_constructible_checks_impl<false, void() &&>();
+  copy_constructible_checks_impl<false, void() const &&>();
+  copy_constructible_checks_impl<false, void() volatile &&>();
+  copy_constructible_checks_impl<false, void() const volatile &&>();
+}
+
+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;
+};
+
+template <bool expected, typename T>
+void move_constructible_checks_impl() {
+  { int arr[T(__is_move_constructible(T) == expected)]; }                // expected-error{{incomplete type}}
+  { int arr[T(__is_move_constructible(const T) == expected)]; }          // expected-error{{incomplete type}}
+  { int arr[T(__is_move_constructible(volatile T) == expected)]; }       // expected-error{{incomplete type}}
+  { int arr[T(__is_move_constructible(const volatile T) == expected)]; } // expected-error{{incomplete type}}
+}
+
+void move_constructible_checks() {
+  // Builtin types
+  move_constructible_checks_impl<true, int>();
+  move_constructible_checks_impl<false, int &>();
+  move_constructible_checks_impl<true, int &&>();
+  move_constructible_checks_impl<true, int *>();
+  move_constructible_checks_impl<false, int[5]>();
+  move_constructible_checks_impl<false, int[]>();
+  move_constructible_checks_impl<true, decltype(nullptr)>();
+  move_constructible_checks_impl<true, void (*)()>();
+  move_constructible_checks_impl<true, void (&)()>();
+  move_constructible_checks_impl<true, int Empty::*>();
+  move_constructible_checks_impl<true, int (Empty::*)()>();
+  move_constructible_checks_impl<true, int (Empty::*)() const>();
+  move_constructible_checks_impl<true, int (Empty::*)() volatile>();
+  move_constructible_checks_impl<true, int (Empty::*)() const volatile>();
+  move_constructible_checks_impl<true, int (Empty::*)() &>();
+  move_constructible_checks_impl<true, int (Empty::*)() const &>();
+  move_constructible_checks_impl<true, int (Empty::*)() volatile &>();
+  move_constructible_checks_impl<true, int (Empty::*)() const volatile &>();
+  move_constructible_checks_impl<true, int (Empty::*)() &&>();
+  move_constructible_checks_impl<true, int (Empty::*)() const &&>();
+  move_constructible_checks_impl<true, int (Empty::*)() volatile &&>();
+  move_constructible_checks_impl<true, int (Empty::*)() const volatile &&>();
+
+  // // User-defined types
+  move_constructible_checks_impl<true, AllDefaulted>();
+  move_constructible_checks_impl<true, AllDefaulted>();
+  move_constructible_checks_impl<true, CEmptyStruct>();
+  move_constructible_checks_impl<true, ConstMoveCtor>();
+  move_constructible_checks_impl<true, CppEmptyStruct>();
+  move_constructible_checks_impl<true, CppStructNonStandardBy2ndVirtBase>();
+  move_constructible_checks_impl<true, CppStructNonStandardByBase>();
+  move_constructible_checks_impl<true, CppStructNonStandardByMemb>();
+  move_constructible_checks_impl<true, CppStructNonStandardByProt>();
+  move_constructible_checks_impl<true, CppStructNonStandardBySameBase>();
+  move_constructible_checks_impl<true, CppStructNonStandardByVirt>();
+  move_constructible_checks_impl<true, CppStructNonStandardByVirtBase>();
+  move_constructible_checks_impl<true, CppStructStandard>();
+  move_constructible_checks_impl<true, CStruct>();
+  move_constructible_checks_impl<true, CVMoveCtor>();
+  move_constructible_checks_impl<true, Derives>();
+  move_constructible_checks_impl<true, DerivesHasRef>();
+  move_constructible_checks_impl<true, Empty>();
+  move_constructible_checks_impl<true, EmptyUnion>();
+  move_constructible_checks_impl<true, Enum>();
+  move_constructible_checks_impl<true, EnumClass>();
+  move_constructible_checks_impl<true, ExtDefaulted>();
+  move_constructible_checks_impl<true, ExtDefaulted>();
+  move_constructible_checks_impl<true, HasCons>();
+  move_constructible_checks_impl<true, HasCopyAssign>();
+  move_constructible_checks_impl<true, HasDest>();
+  move_constructible_checks_impl<true, HasMove>();
+  move_constructible_checks_impl<true, HasPriv>();
+  move_constructible_checks_impl<true, HasRef>();
+  move_constructible_checks_impl<true, HasTemplateCons>();
+  move_constructible_checks_impl<true, NoDefaultMoveAssignDueToDtor>();
+  move_constructible_checks_impl<true, NoDefaultMoveAssignDueToUDCopyAssign>();
+  move_constructible_checks_impl<true, NoDefaultMoveAssignDueToUDCopyCtor>();
+  move_constructible_checks_impl<true, NonTCStruct>();
+  move_constructible_checks_impl<true, NonTrivialStruct>();
+  move_constructible_checks_impl<true, POD>();
+  move_constructible_checks_impl<true, SuperNonTrivialStruct>();
+  move_constructible_checks_impl<true, TrivialStruct>();
+  move_constructible_checks_impl<true, Union>();
+  move_constructible_checks_impl<true, VolatileMoveCtor>();
+
+  move_constructible_checks_impl<false, AllDeleted>();
+  move_constructible_checks_impl<false, AllPrivate>();
+  move_constructible_checks_impl<false, AnIncompleteType[]>();
+  move_constructible_checks_impl<false, AnIncompleteType>(); // expected-note{{in instantiation of function template specialization}}
+  move_constructible_checks_impl<false, BaseDeletedCopyCtor>();
+  move_constructible_checks_impl<false, BaseDeletedCopyCtor>();
+  move_constructible_checks_impl<false, BaseDeletedMoveCtor>();
+  move_constructible_checks_impl<false, CopyCtorDeleted>();
+  move_constructible_checks_impl<false, CopyCtorDeleted>();
+  move_constructible_checks_impl<false, CVCopyCtor>();
+  move_constructible_checks_impl<false, HasMutableCopyCtor>();
+  move_constructible_checks_impl<false, HasMoveAssign>();
+  move_constructible_checks_impl<false, MemberDeletedCopyCtor>();
+  move_constructible_checks_impl<false, MemberDeletedCopyCtor>();
+  move_constructible_checks_impl<false, MemberDeletedMoveCtor>();
+  move_constructible_checks_impl<false, MoveCtorDeleted>();
+  move_constructible_checks_impl<false, VirtAr>();
+  move_constructible_checks_impl<false, VolatileCopyCtor>();
+
+  // Non-referencable types
+  move_constructible_checks_impl<false, void>();
+  move_constructible_checks_impl<false, void()>();
+  move_constructible_checks_impl<false, void() const>();
+  move_constructible_checks_impl<false, void() volatile>();
+  move_constructible_checks_impl<false, void() const volatile>();
+  move_constructible_checks_impl<false, void() &>();
+  move_constructible_checks_impl<false, void() const &>();
+  move_constructible_checks_impl<false, void() volatile &>();
+  move_constructible_checks_impl<false, void() const volatile &>();
+  move_constructible_checks_impl<false, void() &&>();
+  move_constructible_checks_impl<false, void() const &&>();
+  move_constructible_checks_impl<false, void() volatile &&>();
+  move_constructible_checks_impl<false, void() const volatile &&>();
+}
+
+struct MutableCopyAssign_QualNone {
+  MutableCopyAssign_QualNone &operator=(MutableCopyAssign_QualNone &);
+};
+struct MutableCopyAssign_QualConst {
+  MutableCopyAssign_QualConst &operator=(MutableCopyAssign_QualConst &) const;
+};
+struct MutableCopyAssign_QualVolatile {
+  MutableCopyAssign_QualVolatile &operator=(MutableCopyAssign_QualVolatile &) volatile;
+};
+struct MutableCopyAssign_QualCV {
+  MutableCopyAssign_QualCV &operator=(MutableCopyAssign_QualCV &) const volatile;
+};
+struct MutableCopyAssign_QualLvalue {
+  MutableCopyAssign_QualLvalue &operator=(MutableCopyAssign_QualLvalue &) &;
+};
+struct MutableCopyAssign_QualConstLvalue {
+  MutableCopyAssign_QualConstLvalue &operator=(MutableCopyAssign_QualConstLvalue &) const &;
+};
+struct MutableCopyAssign_QualVolatileLvalue {
+  MutableCopyAssign_QualVolatileLvalue &operator=(MutableCopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct MutableCopyAssign_QualCVLvalue {
+  MutableCopyAssign_QualCVLvalue &operator=(MutableCopyAssign_QualCVLvalue &) const volatile &;
+};
+struct MutableCopyAssign_QualRvalue {
+  MutableCopyAssign_QualRvalue &operator=(MutableCopyAssign_QualRvalue &) &&;
+};
+struct MutableCopyAssign_QualConstRvalue {
+  MutableCopyAssign_QualConstRvalue &operator=(MutableCopyAssign_QualConstRvalue &) const &&;
+};
+struct MutableCopyAssign_QualVolatileRvalue {
+  MutableCopyAssign_QualVolatileRvalue &operator=(MutableCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct MutableCopyAssign_QualCVRvalue {
+  MutableCopyAssign_QualCVRvalue &operator=(MutableCopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct CopyAssign_QualNone {
+  CopyAssign_QualNone &operator=(const CopyAssign_QualNone &);
+};
+struct CopyAssign_QualConst {
+  CopyAssign_QualConst &operator=(const CopyAssign_QualConst &) const;
+};
+struct CopyAssign_QualVolatile {
+  CopyAssign_QualVolatile &operator=(const CopyAssign_QualVolatile &) volatile;
+};
+struct CopyAssign_QualCV {
+  CopyAssign_QualCV &operator=(const CopyAssign_QualCV &) const volatile;
+};
+struct CopyAssign_QualLvalue {
+  CopyAssign_QualLvalue &operator=(const CopyAssign_QualLvalue &) &;
+};
+struct CopyAssign_QualConstLvalue {
+  CopyAssign_QualConstLvalue &operator=(const CopyAssign_QualConstLvalue &) const &;
+};
+struct CopyAssign_QualVolatileLvalue {
+  CopyAssign_QualVolatileLvalue &operator=(const CopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct CopyAssign_QualCVLvalue {
+  CopyAssign_QualCVLvalue &operator=(const CopyAssign_QualCVLvalue &) const volatile &;
+};
+struct CopyAssign_QualRvalue {
+  CopyAssign_QualRvalue &operator=(const CopyAssign_QualRvalue &) &&;
+};
+struct CopyAssign_QualConstRvalue {
+  CopyAssign_QualConstRvalue &operator=(const CopyAssign_QualConstRvalue &) const &&;
+};
+struct CopyAssign_QualVolatileRvalue {
+  CopyAssign_QualVolatileRvalue &operator=(const CopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct CopyAssign_QualCVRvalue {
+  CopyAssign_QualCVRvalue &operator=(const CopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct VolatileCopyAssign_QualNone {
+  VolatileCopyAssign_QualNone &operator=(volatile VolatileCopyAssign_QualNone &);
+};
+struct VolatileCopyAssign_QualConst {
+  VolatileCopyAssign_QualConst &operator=(volatile VolatileCopyAssign_QualConst &) const;
+};
+struct VolatileCopyAssign_QualVolatile {
+  VolatileCopyAssign_QualVolatile &operator=(volatile VolatileCopyAssign_QualVolatile &) volatile;
+};
+struct VolatileCopyAssign_QualCV {
+  VolatileCopyAssign_QualCV &operator=(volatile VolatileCopyAssign_QualCV &) const volatile;
+};
+struct VolatileCopyAssign_QualLvalue {
+  VolatileCopyAssign_QualLvalue &operator=(volatile VolatileCopyAssign_QualLvalue &) &;
+};
+struct VolatileCopyAssign_QualConstLvalue {
+  VolatileCopyAssign_QualConstLvalue &operator=(volatile VolatileCopyAssign_QualConstLvalue &) const &;
+};
+struct VolatileCopyAssign_QualVolatileLvalue {
+  VolatileCopyAssign_QualVolatileLvalue &operator=(volatile VolatileCopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct VolatileCopyAssign_QualCVLvalue {
+  VolatileCopyAssign_QualCVLvalue &operator=(volatile VolatileCopyAssign_QualCVLvalue &) const volatile &;
+};
+struct VolatileCopyAssign_QualRvalue {
+  VolatileCopyAssign_QualRvalue &operator=(volatile VolatileCopyAssign_QualRvalue &) &&;
+};
+struct VolatileCopyAssign_QualConstRvalue {
+  VolatileCopyAssign_QualConstRvalue &operator=(volatile VolatileCopyAssign_QualConstRvalue &) const &&;
+};
+struct VolatileCopyAssign_QualVolatileRvalue {
+  VolatileCopyAssign_QualVolatileRvalue &operator=(volatile VolatileCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct VolatileCopyAssign_QualCVRvalue {
+  VolatileCopyAssign_QualCVRvalue &operator=(volatile VolatileCopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct CVCopyAssign_QualNone {
+  CVCopyAssign_QualNone &operator=(const volatile CVCopyAssign_QualNone &);
+};
+struct CVCopyAssign_QualConst {
+  CVCopyAssign_QualConst &operator=(const volatile CVCopyAssign_QualConst &) const;
+};
+struct CVCopyAssign_QualVolatile {
+  CVCopyAssign_QualVolatile &operator=(const volatile CVCopyAssign_QualVolatile &) volatile;
+};
+struct CVCopyAssign_QualCV {
+  CVCopyAssign_QualCV &operator=(const volatile CVCopyAssign_QualCV &) const volatile;
+};
+struct CVCopyAssign_QualLvalue {
+  CVCopyAssign_QualLvalue &operator=(const volatile CVCopyAssign_QualLvalue &) &;
+};
+struct CVCopyAssign_QualConstLvalue {
+  CVCopyAssign_QualConstLvalue &operator=(const volatile CVCopyAssign_QualConstLvalue &) const &;
+};
+struct CVCopyAssign_QualCVLvalue {
+  CVCopyAssign_QualCVLvalue &operator=(const volatile CVCopyAssign_QualCVLvalue &) volatile &;
+};
+struct CVCopyAssign_QualVolatileLvalue {
+  CVCopyAssign_QualVolatileLvalue &operator=(const volatile CVCopyAssign_QualVolatileLvalue &) const volatile &;
+};
+struct CVCopyAssign_QualRvalue {
+  CVCopyAssign_QualRvalue &operator=(const volatile CVCopyAssign_QualRvalue &) &&;
+};
+struct CVCopyAssign_QualConstRvalue {
+  CVCopyAssign_QualConstRvalue &operator=(const volatile CVCopyAssign_QualConstRvalue &) const &&;
+};
+struct CVCopyAssign_QualVolatileRvalue {
+  CVCopyAssign_QualVolatileRvalue &operator=(const volatile CVCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct CVCopyAssign_QualCVRvalue {
+  CVCopyAssign_QualCVRvalue &operator=(const volatile CVCopyAssign_QualCVRvalue &) const volatile &&;
+};
+struct CopyAssignDeleted {
+  CopyAssignDeleted &operator=(const CopyAssignDeleted &) = delete;
+};
+struct BaseDeletedCopyAssign : CopyAssignDeleted {};
+struct HasMemberWithDeletedCopyAssign {
+  CopyAssignDeleted x;
+};
+
+void copy_assignable_checks() {
+  // Builtin types
+  { int a[T(__is_copy_assignable(int))]; }
+  { int a[T(__is_copy_assignable(int &))]; }
+  { int a[T(__is_copy_assignable(int &&))]; }
+  { int a[T(__is_copy_assignable(int *))]; }
+  { int a[F(__is_copy_assignable(int[5]))]; }
+  { int a[F(__is_copy_assignable(int[]))]; }
+  { int a[T(__is_copy_assignable(decltype(nullptr)))]; }
+  { int a[T(__is_copy_assignable(void (*)()))]; }
+  { int a[F(__is_copy_assignable(void (&)()))]; }
+  { int a[T(__is_copy_assignable(int Empty::*))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)()))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() const))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() volatile))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() const volatile))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() &))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() const &))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() volatile &))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() const volatile &))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() &&))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() const &&))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() volatile &&))]; }
+  { int a[T(__is_copy_assignable(int(Empty::*)() const volatile &&))]; }
+
+  // // User-defined types
+  { int a[T(__is_copy_assignable(AllDefaulted))]; }
+  { int a[T(__is_copy_assignable(AllDefaulted))]; }
+  { int a[T(__is_copy_assignable(BaseDeletedCopyCtor))]; }
+  { int a[T(__is_copy_assignable(CEmptyStruct))]; }
+  { int a[T(__is_copy_assignable(CopyCtorDeleted))]; }
+  { int a[T(__is_copy_assignable(CppEmptyStruct))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardBy2ndVirtBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByMemb))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByProt))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardBySameBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByVirt))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByVirtBase))]; }
+  { int a[T(__is_copy_assignable(CppStructStandard))]; }
+  { int a[T(__is_copy_assignable(CStruct))]; }
+  { int a[T(__is_copy_assignable(CVCopyCtor))]; }
+  { int a[T(__is_copy_assignable(Derives))]; }
+  { int a[T(__is_copy_assignable(DerivesHasCopyAssign))]; }
+  { int a[T(__is_copy_assignable(Empty))]; }
+  { int a[T(__is_copy_assignable(EmptyUnion))]; }
+  { int a[T(__is_copy_assignable(Enum))]; }
+  { int a[T(__is_copy_assignable(EnumClass))]; }
+  { int a[T(__is_copy_assignable(ExtDefaulted))]; }
+  { int a[T(__is_copy_assignable(ExtDefaulted))]; }
+  { int a[T(__is_copy_assignable(HasCons))]; }
+  { int a[T(__is_copy_assignable(HasCopyAssign))]; }
+  { int a[T(__is_copy_assignable(HasDest))]; }
+  { int a[T(__is_copy_assignable(HasMutableCopyCtor))]; }
+  { int a[T(__is_copy_assignable(HasPriv))]; }
+  { int a[T(__is_copy_assignable(HasMultipleCopyAssign))]; }
+  { int a[T(__is_copy_assignable(HasTemplateCons))]; }
+  { int a[T(__is_copy_assignable(MemberDeletedCopyCtor))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToDtor))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int a[T(__is_copy_assignable(NonTCStruct))]; }
+  { int a[T(__is_copy_assignable(NonTrivialStruct))]; }
+  { int a[T(__is_copy_assignable(POD))]; }
+  { int a[T(__is_copy_assignable(SuperNonTrivialStruct))]; }
+  { int a[T(__is_copy_assignable(TrivialStruct))]; }
+  { int a[T(__is_copy_assignable(Union))]; }
+
+  { int a[F(__is_copy_assignable(AllDeleted))]; }
+  { int a[F(__is_copy_assignable(AllPrivate))]; }
+  { int a[F(__is_copy_assignable(AnIncompleteType[]))]; }
+  { int a[F(__is_copy_assignable(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int a[F(__is_copy_assignable(DerivesHasRef))]; }
+  { int a[F(__is_copy_assignable(HasRef))]; }
+  { int a[F(__is_copy_assignable(HasMove))]; }
+  { int a[F(__is_copy_assignable(HasMoveAssign))]; }
+  { int a[F(__is_copy_assignable(VirtAr))]; }
+  { int a[F(__is_copy_assignable(CopyAssignDeleted))]; }
+  { int a[F(__is_copy_assignable(BaseDeletedCopyAssign))]; }
+  { int a[F(__is_copy_assignable(HasMemberWithDeletedCopyAssign))]; }
+
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualNone))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConstLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCVRvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualNone))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualConstLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualVolatileLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualCVRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualNone))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConstLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCVRvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualNone))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualConstLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualVolatileLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualCVRvalue))]; }
+
+  // Non-referencable types
+  { int a[F(__is_copy_assignable(void))]; }
+  { int a[F(__is_copy_assignable(void()))]; }
+
+  // cv-qualified types
+  { int a[F(__is_copy_assignable(const int))]; }
+  { int a[F(__is_copy_assignable(const Empty))]; }
+  { int a[T(__is_copy_assignable(volatile int))]; }
+  { int a[F(__is_copy_assignable(volatile Empty))]; }
+  { int a[F(__is_copy_assignable(const volatile int))]; }
+  { int a[F(__is_copy_assignable(const volatile Empty))]; }
+
+  { int a[T(__is_copy_assignable(const CopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(volatile CopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(const volatile CopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(const VolatileCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(volatile VolatileCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(const volatile VolatileCopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(const CVCopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(volatile CVCopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(const volatile CVCopyAssign_QualCV))]; }
+}
+
+struct MoveAssign_QualNone {
+  MoveAssign_QualNone &operator=(MoveAssign_QualNone &&);
+};
+struct MoveAssign_QualConst {
+  MoveAssign_QualConst &operator=(MoveAssign_QualConst &&) const;
+};
+struct MoveAssign_QualVolatile {
+  MoveAssign_QualVolatile &operator=(MoveAssign_QualVolatile &&) volatile;
+};
+struct MoveAssign_QualCV {
+  MoveAssign_QualCV &operator=(MoveAssign_QualCV &&) const volatile;
+};
+struct MoveAssign_QualLvalue {
+  MoveAssign_QualLvalue &operator=(MoveAssign_QualLvalue &&) &;
+};
+struct MoveAssign_QualConstLvalue {
+  MoveAssign_QualConstLvalue &operator=(MoveAssign_QualConstLvalue &&) const &;
+};
+struct MoveAssign_QualVolatileLvalue {
+  MoveAssign_QualVolatileLvalue &operator=(MoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct MoveAssign_QualCVLvalue {
+  MoveAssign_QualCVLvalue &operator=(MoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct MoveAssign_QualRvalue {
+  MoveAssign_QualRvalue &operator=(MoveAssign_QualRvalue &&) &&;
+};
+struct MoveAssign_QualConstRvalue {
+  MoveAssign_QualConstRvalue &operator=(MoveAssign_QualConstRvalue &&) const &&;
+};
+struct MoveAssign_QualVolatileRvalue {
+  MoveAssign_QualVolatileRvalue &operator=(MoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct MoveAssign_QualCVRvalue {
+  MoveAssign_QualCVRvalue &operator=(MoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct ConstMoveAssign_QualNone {
+  ConstMoveAssign_QualNone &operator=(const ConstMoveAssign_QualNone &&);
+};
+struct ConstMoveAssign_QualConst {
+  ConstMoveAssign_QualConst &operator=(const ConstMoveAssign_QualConst &&) const;
+};
+struct ConstMoveAssign_QualVolatile {
+  ConstMoveAssign_QualVolatile &operator=(const ConstMoveAssign_QualVolatile &&) volatile;
+};
+struct ConstMoveAssign_QualCV {
+  ConstMoveAssign_QualCV &operator=(const ConstMoveAssign_QualCV &&) const volatile;
+};
+struct ConstMoveAssign_QualLvalue {
+  ConstMoveAssign_QualLvalue &operator=(const ConstMoveAssign_QualLvalue &&) &;
+};
+struct ConstMoveAssign_QualConstLvalue {
+  ConstMoveAssign_QualConstLvalue &operator=(const ConstMoveAssign_QualConstLvalue &&) const &;
+};
+struct ConstMoveAssign_QualVolatileLvalue {
+  ConstMoveAssign_QualVolatileLvalue &operator=(const ConstMoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct ConstMoveAssign_QualCVLvalue {
+  ConstMoveAssign_QualCVLvalue &operator=(const ConstMoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct ConstMoveAssign_QualRvalue {
+  ConstMoveAssign_QualRvalue &operator=(const ConstMoveAssign_QualRvalue &&) &&;
+};
+struct ConstMoveAssign_QualConstRvalue {
+  ConstMoveAssign_QualConstRvalue &operator=(const ConstMoveAssign_QualConstRvalue &&) const &&;
+};
+struct ConstMoveAssign_QualVolatileRvalue {
+  ConstMoveAssign_QualVolatileRvalue &operator=(const ConstMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct ConstMoveAssign_QualCVRvalue {
+  ConstMoveAssign_QualCVRvalue &operator=(const ConstMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct VolatileMoveAssign_QualNone {
+  VolatileMoveAssign_QualNone &operator=(volatile VolatileMoveAssign_QualNone &&);
+};
+struct VolatileMoveAssign_QualConst {
+  VolatileMoveAssign_QualConst &operator=(volatile VolatileMoveAssign_QualConst &&) const;
+};
+struct VolatileMoveAssign_QualVolatile {
+  VolatileMoveAssign_QualVolatile &operator=(volatile VolatileMoveAssign_QualVolatile &&) volatile;
+};
+struct VolatileMoveAssign_QualCV {
+  VolatileMoveAssign_QualCV &operator=(volatile VolatileMoveAssign_QualCV &&) const volatile;
+};
+struct VolatileMoveAssign_QualLvalue {
+  VolatileMoveAssign_QualLvalue &operator=(volatile VolatileMoveAssign_QualLvalue &&) &;
+};
+struct VolatileMoveAssign_QualConstLvalue {
+  VolatileMoveAssign_QualConstLvalue &operator=(volatile VolatileMoveAssign_QualConstLvalue &&) const &;
+};
+struct VolatileMoveAssign_QualVolatileLvalue {
+  VolatileMoveAssign_QualVolatileLvalue &operator=(volatile VolatileMoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct VolatileMoveAssign_QualCVLvalue {
+  VolatileMoveAssign_QualCVLvalue &operator=(volatile VolatileMoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct VolatileMoveAssign_QualRvalue {
+  VolatileMoveAssign_QualRvalue &operator=(volatile VolatileMoveAssign_QualRvalue &&) &&;
+};
+struct VolatileMoveAssign_QualConstRvalue {
+  VolatileMoveAssign_QualConstRvalue &operator=(volatile VolatileMoveAssign_QualConstRvalue &&) const &&;
+};
+struct VolatileMoveAssign_QualVolatileRvalue {
+  VolatileMoveAssign_QualVolatileRvalue &operator=(volatile VolatileMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct VolatileMoveAssign_QualCVRvalue {
+  VolatileMoveAssign_QualCVRvalue &operator=(volatile VolatileMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct CVMoveAssign_QualNone {
+  CVMoveAssign_QualNone &operator=(const volatile CVMoveAssign_QualNone &&);
+};
+struct CVMoveAssign_QualConst {
+  CVMoveAssign_QualConst &operator=(const volatile CVMoveAssign_QualConst &&) const;
+};
+struct CVMoveAssign_QualVolatile {
+  CVMoveAssign_QualVolatile &operator=(const volatile CVMoveAssign_QualVolatile &&) volatile;
+};
+struct CVMoveAssign_QualCV {
+  CVMoveAssign_QualCV &operator=(const volatile CVMoveAssign_QualCV &&) const volatile;
+};
+struct CVMoveAssign_QualLvalue {
+  CVMoveAssign_QualLvalue &operator=(const volatile CVMoveAssign_QualLvalue &&) &;
+};
+struct CVMoveAssign_QualConstLvalue {
+  CVMoveAssign_QualConstLvalue &operator=(const volatile CVMoveAssign_QualConstLvalue &&) const &;
+};
+struct CVMoveAssign_QualCVLvalue {
+  CVMoveAssign_QualCVLvalue &operator=(const volatile CVMoveAssign_QualCVLvalue &&) volatile &;
+};
+struct CVMoveAssign_QualVolatileLvalue {
+  CVMoveAssign_QualVolatileLvalue &operator=(const volatile CVMoveAssign_QualVolatileLvalue &&) const volatile &;
+};
+struct CVMoveAssign_QualRvalue {
+  CVMoveAssign_QualRvalue &operator=(const volatile CVMoveAssign_QualRvalue &&) &&;
+};
+struct CVMoveAssign_QualConstRvalue {
+  CVMoveAssign_QualConstRvalue &operator=(const volatile CVMoveAssign_QualConstRvalue &&) const &&;
+};
+struct CVMoveAssign_QualVolatileRvalue {
+  CVMoveAssign_QualVolatileRvalue &operator=(const volatile CVMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct CVMoveAssign_QualCVRvalue {
+  CVMoveAssign_QualCVRvalue &operator=(const volatile CVMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+struct MoveAssignDeleted {
+  MoveAssignDeleted &operator=(const MoveAssignDeleted &&) = delete;
+};
+struct BaseDeletedMoveAssign : MoveAssignDeleted {};
+struct HasMemberWithDeletedMoveAssign {
+  MoveAssignDeleted x;
+};
+
+void move_assignable_checks() {
+  // Builtin types
+  { int a[T(__is_move_assignable(int))]; }
+  { int a[T(__is_move_assignable(int &))]; }
+  { int a[T(__is_move_assignable(int &&))]; }
+  { int a[T(__is_move_assignable(int *))]; }
+  { int a[F(__is_move_assignable(int[5]))]; }
+  { int a[F(__is_move_assignable(int[]))]; }
+  { int a[T(__is_move_assignable(decltype(nullptr)))]; }
+  { int a[T(__is_move_assignable(void (*)()))]; }
+  { int a[F(__is_move_assignable(void (&)()))]; }
+  { int a[T(__is_move_assignable(int Empty::*))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)()))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile &&))]; }
+
+  // // User-defined types
+  { int a[T(__is_move_assignable(AllDefaulted))]; }
+  { int a[T(__is_move_assignable(AllDefaulted))]; }
+  { int a[T(__is_move_assignable(BaseDeletedCopyCtor))]; }
+  { int a[T(__is_move_assignable(CEmptyStruct))]; }
+  { int a[T(__is_move_assignable(CopyCtorDeleted))]; }
+  { int a[T(__is_move_assignable(CppEmptyStruct))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardBy2ndVirtBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByMemb))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByProt))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardBySameBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByVirt))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByVirtBase))]; }
+  { int a[T(__is_move_assignable(CppStructStandard))]; }
+  { int a[T(__is_move_assignable(CStruct))]; }
+  { int a[T(__is_move_assignable(CVCopyCtor))]; }
+  { int a[T(__is_move_assignable(Derives))]; }
+  { int a[T(__is_move_assignable(DerivesHasCopyAssign))]; }
+  { int a[T(__is_move_assignable(Empty))]; }
+  { int a[T(__is_move_assignable(EmptyUnion))]; }
+  { int a[T(__is_move_assignable(Enum))]; }
+  { int a[T(__is_move_assignable(EnumClass))]; }
+  { int a[T(__is_move_assignable(ExtDefaulted))]; }
+  { int a[T(__is_move_assignable(ExtDefaulted))]; }
+  { int a[T(__is_move_assignable(HasCons))]; }
+  { int a[T(__is_move_assignable(HasCopyAssign))]; }
+  { int a[T(__is_move_assignable(HasDest))]; }
+  { int a[T(__is_move_assignable(HasMutableCopyCtor))]; }
+  { int a[T(__is_move_assignable(HasPriv))]; }
+  { int a[T(__is_move_assignable(HasMultipleCopyAssign))]; }
+  { int a[T(__is_move_assignable(HasTemplateCons))]; }
+  { int a[T(__is_move_assignable(MemberDeletedCopyCtor))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToDtor))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int a[T(__is_move_assignable(NonTCStruct))]; }
+  { int a[T(__is_move_assignable(NonTrivialStruct))]; }
+  { int a[T(__is_move_assignable(POD))]; }
+  { int a[T(__is_move_assignable(SuperNonTrivialStruct))]; }
+  { int a[T(__is_move_assignable(TrivialStruct))]; }
+  { int a[T(__is_move_assignable(Union))]; }
+  { int a[T(__is_move_assignable(HasMoveAssign))]; }
+
+  { int a[F(__is_move_assignable(AllDeleted))]; }
+  { int a[F(__is_move_assignable(AllPrivate))]; }
+  { int a[F(__is_move_assignable(AnIncompleteType[]))]; }
+  { int a[F(__is_move_assignable(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int a[F(__is_move_assignable(DerivesHasRef))]; }
+  { int a[F(__is_move_assignable(HasRef))]; }
+  { int a[F(__is_move_assignable(HasMove))]; }
+  { int a[F(__is_move_assignable(VirtAr))]; }
+  { int a[F(__is_move_assignable(MoveAssignDeleted))]; }
+  { int a[F(__is_move_assignable(BaseDeletedMoveAssign))]; }
+  { int a[F(__is_move_assignable(HasMemberWithDeletedMoveAssign))]; }
+
+  { int a[T(__is_move_assignable(MoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(MoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(ConstMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(ConstMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(VolatileMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(VolatileMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(CVMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(CVMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCVRvalue))]; }
+
+  // Non-referencable types
+  { int a[F(__is_move_assignable(void))]; }
+  { int a[F(__is_move_assignable(void()))]; }
+
+  // cv-qualified types
+  { int a[F(__is_move_assignable(const int))]; }
+  { int a[F(__is_move_assignable(const Empty))]; }
+  { int a[T(__is_move_assignable(volatile int))]; }
+  { int a[F(__is_move_assignable(volatile Empty))]; }
+  { int a[F(__is_move_assignable(const volatile int))]; }
+  { int a[F(__is_move_assignable(const volatile Empty))]; }
+
+  { int a[T(__is_move_assignable(const MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(volatile MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(const volatile MoveAssign_QualConst))]; }
+  { int a[T(__is_move_assignable(volatile MoveAssign_QualVolatile))]; }
+  { int a[T(__is_move_assignable(const volatile MoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(const VolatileMoveAssign_QualConst))]; }
+  { int a[T(__is_move_assignable(volatile VolatileMoveAssign_QualVolatile))]; }
+  { int a[T(__is_move_assignable(const volatile VolatileMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(const CVMoveAssign_QualConst))]; }
+  { int a[T(__is_move_assignable(volatile CVMoveAssign_QualVolatile))]; }
+  { int a[T(__is_move_assignable(const volatile CVMoveAssign_QualCV))]; }
+}
+
 // Instantiation of __is_trivially_constructible
 template<typename T, typename ...Args>
 struct is_trivially_constructible {
   static const bool value = __is_trivially_constructible(T, Args...);
 };
 
 void is_trivially_constructible_test() {
   { int arr[T((is_trivially_constructible<int>::value))]; }
static void checks() {
     static_assert(__is_same(add_rvalue_reference_t<M>, M), "");
     static_assert(__is_same(decay_t<M>, M), "");
     static_assert(__is_same(remove_const_t<M>, M), "");
     static_assert(__is_same(remove_volatile_t<M>, M), "");
     static_assert(__is_same(remove_cv_t<M>, M), "");
     static_assert(__is_same(remove_cvref_t<M>, M), "");
     static_assert(__is_same(remove_pointer_t<M>, M), "");
     static_assert(__is_same(remove_reference_t<M>, M), "");
+
+    static_assert(!__is_referenceable(M), "");
   }
 };
 
 void check_abominable_function() {
   { CheckAbominableFunction<int (S::*)() &> x; }
   { CheckAbominableFunction<int (S::*)() &&> x; }
   { CheckAbominableFunction<int (S::*)() const> x; }
   { CheckAbominableFunction<int (S::*)() const &> x; }