[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

4929–4930

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

5328

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

5335

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

4929–4930

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

5335

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

4929–4930

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_nothrow_copy_constructible, IsNothrowCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_copy_assignable, IsCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_copy_assignable, IsNothrowCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_move_constructible, IsMoveConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_move_constructible, IsNothrowMoveConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_move_assignable, IsMoveAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_move_assignable, IsNothrowMoveAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_copy_constructible, IsTriviallyCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_copy_assignable, IsTriviallyCopyAssignable, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_move_constructible, IsTriviallyMoveConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_move_assignable, IsTriviallyMoveAssignable, KEYCXX)
 
 // MSVC14.0 / VS2015 Type Traits
 TYPE_TRAIT_2(__is_assignable, IsAssignable, KEYCXX)
 
 // 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)
+TYPE_TRAIT_2(__reference_constructs_from_temporary, ReferenceConstructsFromTemporary, KEYCXX)
+TYPE_TRAIT_2(__reference_converts_from_temporary, ReferenceConvertsFromTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 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/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
           if (II->getName().startswith("__builtin_") ||
               II->getName().startswith("__is_") ||
               II->getName().startswith("__has_"))
             return true;
           return llvm::StringSwitch<bool>(II->getName())
               .Case("__array_rank", true)
               .Case("__array_extent", true)
               .Case("__reference_binds_to_temporary", true)
+              .Case("__reference_constructs_from_temporary", true)
+              .Case("__reference_converts_from_temporary", true)
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) .Case("__" #Trait, true)
 #include "clang/Basic/TransformTypeTraits.def"
               .Default(false);
         } else {
           return llvm::StringSwitch<bool>(II->getName())
               // Report builtin templates as being builtins.
               .Case("__make_integer_seq", getLangOpts().CPlusPlus)
               .Case("__type_pack_element", getLangOpts().CPlusPlus)

clang/lib/Parse/ParseDeclCXX.cpp

if (TagType == DeclSpec::TST_struct && Tok.isNot(tok::identifier) &&
       Tok.isOneOf(
 #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_copy_assignable,
+          tok::kw___is_move_assignable,
           tok::kw___is_base_of,
+          tok::kw___is_bounded_array,
           tok::kw___is_class,
           tok::kw___is_complete_type,
           tok::kw___is_compound,
           tok::kw___is_const,
           tok::kw___is_constructible,
+          tok::kw___is_copy_constructible,
+          tok::kw___is_move_constructible,
           tok::kw___is_convertible,
           tok::kw___is_convertible_to,
           tok::kw___is_destructible,
           tok::kw___is_empty,
           tok::kw___is_enum,
           tok::kw___is_floating_point,
           tok::kw___is_final,
           tok::kw___is_function,
           tok::kw___is_fundamental,
           tok::kw___is_integral,
           tok::kw___is_interface_class,
           tok::kw___is_literal,
           tok::kw___is_lvalue_expr,
           tok::kw___is_lvalue_reference,
           tok::kw___is_member_function_pointer,
           tok::kw___is_member_object_pointer,
           tok::kw___is_member_pointer,
           tok::kw___is_nothrow_assignable,
+          tok::kw___is_nothrow_copy_assignable,
+          tok::kw___is_nothrow_move_assignable,
           tok::kw___is_nothrow_constructible,
+          tok::kw___is_nothrow_copy_constructible,
+          tok::kw___is_nothrow_move_constructible,
           tok::kw___is_nothrow_destructible,
+          tok::kw___is_nullptr,
           tok::kw___is_object,
           tok::kw___is_pod,
           tok::kw___is_pointer,
           tok::kw___is_polymorphic,
           tok::kw___is_reference,
+          tok::kw___is_referenceable,
           tok::kw___is_rvalue_expr,
           tok::kw___is_rvalue_reference,
           tok::kw___is_same,
           tok::kw___is_scalar,
+          tok::kw___is_scoped_enum,
           tok::kw___is_sealed,
           tok::kw___is_signed,
           tok::kw___is_standard_layout,
           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_IsTriviallyCopyConstructible:
+  case UTT_IsNothrowCopyConstructible:
+  case UTT_IsCopyAssignable:
+  case UTT_IsTriviallyCopyAssignable:
+  case UTT_IsNothrowCopyAssignable:
+  case UTT_IsMoveConstructible:
+  case UTT_IsTriviallyMoveConstructible:
+  case UTT_IsNothrowMoveConstructible:
+  case UTT_IsMoveAssignable:
+  case UTT_IsTriviallyMoveAssignable:
+  case UTT_IsNothrowMoveAssignable:
     if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType())
       return true;
 
     return !S.RequireCompleteType(
         Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
   }
 }
 
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_IsTriviallyCopyConstructible:
+  case UTT_IsNothrowCopyConstructible:
+  case UTT_IsCopyAssignable:
+  case UTT_IsTriviallyCopyAssignable:
+  case UTT_IsNothrowCopyAssignable: {
+    if (T->isIncompleteArrayType())
+      return false;
+    if (!T.isReferenceable())
+      return false;
+
+    QualType AssigneeType = T;
+    AssigneeType.addConst();
+    AssigneeType = Self.BuiltinAddReference(AssigneeType, UnaryTransformType::AddLvalueReference, KeyLoc);
+    if (UTT == UTT_IsCopyAssignable || UTT == UTT_IsTriviallyCopyAssignable || UTT == UTT_IsNothrowCopyAssignable) {
+      return EvaluateBinaryTypeTrait(
+          Self,
+          UTT == UTT_IsCopyAssignable          ? BTT_IsAssignable
+        : UTT == UTT_IsTriviallyCopyAssignable ? BTT_IsTriviallyAssignable
+                                               : BTT_IsNothrowAssignable,
+          Self.BuildReferenceType(T, true, KeyLoc, T.getBaseTypeIdentifier()),
+          AssigneeType, KeyLoc);
+    }
+    llvm::SmallVector<TypeSourceInfo *, 2> Parameters = {
+        C.CreateTypeSourceInfo(T), C.CreateTypeSourceInfo(AssigneeType)};
+    return evaluateTypeTrait(Self, UTT == UTT_IsCopyConstructible ? TT_IsConstructible :
+                                   UTT == UTT_IsTriviallyCopyConstructible ? TT_IsTriviallyConstructible
+                                                                           : TT_IsNothrowConstructible, KeyLoc, Parameters, {});
+  }
+  case UTT_IsMoveConstructible:
+  case UTT_IsTriviallyMoveConstructible:
+  case UTT_IsNothrowMoveConstructible:
+  case UTT_IsMoveAssignable:
+  case UTT_IsTriviallyMoveAssignable:
+  case UTT_IsNothrowMoveAssignable: {
+    if (T->isIncompleteArrayType())
+      return false;
+    if (!T.isReferenceable())
+      return false;
+
+    QualType AssigneeType = Self.BuiltinAddReference(T, UnaryTransformType::AddRvalueReference, KeyLoc);
+    if (UTT == UTT_IsMoveAssignable || UTT == UTT_IsTriviallyMoveAssignable || UTT == UTT_IsNothrowMoveAssignable)
+      return EvaluateBinaryTypeTrait(
+          Self,
+          UTT == UTT_IsMoveAssignable ? BTT_IsAssignable
+        : UTT == UTT_IsTriviallyMoveAssignable ? BTT_IsTriviallyAssignable : BTT_IsNothrowAssignable,
+          Self.BuildReferenceType(T, true, KeyLoc, T.getBaseTypeIdentifier()),
+          AssigneeType, KeyLoc);
+    llvm::SmallVector<TypeSourceInfo *, 2> Parameters = {
+        C.CreateTypeSourceInfo(T), C.CreateTypeSourceInfo(AssigneeType)};
+    return evaluateTypeTrait(Self, UTT == UTT_IsMoveConstructible ? TT_IsConstructible : UTT == UTT_IsTriviallyMoveConstructible ? TT_IsTriviallyConstructible : TT_IsNothrowConstructible, KeyLoc, Parameters, {});
+  }
+  case UTT_IsReferenceable:
+    return T.isReferenceable();
   }
 }
-
-static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
-                                    QualType RhsT, SourceLocation KeyLoc);
 
 static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
                               ArrayRef<TypeSourceInfo *> Args,
                               SourceLocation RParenLoc) {
   if (Kind <= UTT_Last)
     return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType());
 
-  // Evaluate BTT_ReferenceBindsToTemporary alongside the IsConstructible
-  // traits to avoid duplication.
-  if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary)
+  // Evaluate ReferenceBindsToTemporary and ReferenceConstructsFromTemporary
+  // alongside the IsConstructible traits to avoid duplication.
+  if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary && Kind != BTT_ReferenceConstructsFromTemporary)
     return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(),
                                    Args[1]->getType(), RParenLoc);
 
   switch (Kind) {
   case clang::BTT_ReferenceBindsToTemporary:
+  case clang::BTT_ReferenceConstructsFromTemporary:
   case clang::TT_IsConstructible:
   case clang::TT_IsNothrowConstructible:
   case clang::TT_IsTriviallyConstructible: {
     // C++11 [meta.unary.prop]:
     //   is_trivially_constructible is defined as:
     //
     //     is_constructible<T, Args...>::value is true and the variable
     //     definition for is_constructible, as defined below, is known to call
case clang::TT_IsTriviallyConstructible: {
 
     if (Kind == clang::BTT_ReferenceBindsToTemporary) {
       if (!T->isReferenceType())
         return false;
 
       return !Init.isDirectReferenceBinding();
     }
 
+    if (Kind == clang::BTT_ReferenceConstructsFromTemporary) {
+      QualType U = Args[1]->getType();
+      if (!T->isReferenceType() || U->isReferenceType())
+        return false;
+
+      QualType TPtr = S.BuiltinAddPointer(S.BuiltinRemoveReference(T, UnaryTransformType::RemoveCVRef, {}), {});
+      QualType UPtr = S.BuiltinAddPointer(S.BuiltinRemoveReference(U, UnaryTransformType::RemoveCVRef, {}), {});
+      return EvaluateBinaryTypeTrait(S, TypeTrait::BTT_IsConvertibleTo, UPtr, TPtr, RParenLoc) && Init.isDirectReferenceBinding();
+    }
+
     if (Kind == clang::TT_IsNothrowConstructible)
       return S.canThrow(Result.get()) == CT_Cannot;
 
     if (Kind == clang::TT_IsTriviallyConstructible) {
       // Under Objective-C ARC and Weak, if the destination has non-trivial
       // Objective-C lifetime, this is a non-trivial construction.
       if (T.getNonReferenceType().hasNonTrivialObjCLifetime())
         return false;

 }
 
 namespace {
 void DiagnoseBuiltinDeprecation(Sema& S, TypeTrait Kind,
                                 SourceLocation KWLoc) {
   TypeTrait Replacement;
   switch (Kind) {
     case UTT_HasNothrowAssign:
+      Replacement = UTT_IsNothrowCopyAssignable;
+      break;
     case UTT_HasNothrowMoveAssign:
-      Replacement = BTT_IsNothrowAssignable;
+      Replacement = UTT_IsNothrowMoveAssignable;
       break;
-    case UTT_HasNothrowCopy:
     case UTT_HasNothrowConstructor:
       Replacement = TT_IsNothrowConstructible;
       break;
+    case UTT_HasNothrowCopy:
+      Replacement = UTT_IsNothrowCopyConstructible;
+      break;
     case UTT_HasTrivialAssign:
-    case UTT_HasTrivialMoveAssign:
       Replacement = BTT_IsTriviallyAssignable;
       break;
+    case UTT_HasTrivialMoveAssign:
+      Replacement = UTT_IsTriviallyMoveAssignable;
+      break;
     case UTT_HasTrivialCopy:
       Replacement = UTT_IsTriviallyCopyable;
       break;
     case UTT_HasTrivialDefaultConstructor:
-    case UTT_HasTrivialMoveConstructor:
       Replacement = TT_IsTriviallyConstructible;
       break;
+    case UTT_HasTrivialMoveConstructor:
+      Replacement = UTT_IsTriviallyMoveConstructible;
+      break;
     case UTT_HasTrivialDestructor:
       Replacement = UTT_IsTriviallyDestructible;
       break;
     default:
       return;
   }
   S.Diag(KWLoc, diag::warn_deprecated_builtin)
     << getTraitSpelling(Kind) << getTraitSpelling(Replacement);
static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
   case BTT_TypeCompatible: {
     // GCC ignores cv-qualifiers on arrays for this builtin.
     Qualifiers LhsQuals, RhsQuals;
     QualType Lhs = Self.getASTContext().getUnqualifiedArrayType(LhsT, LhsQuals);
     QualType Rhs = Self.getASTContext().getUnqualifiedArrayType(RhsT, RhsQuals);
     return Self.Context.typesAreCompatible(Lhs, Rhs);
   }
   case BTT_IsConvertible:
-  case BTT_IsConvertibleTo: {
+  case BTT_IsConvertibleTo:
+  case BTT_ReferenceConvertsFromTemporary: {
     // C++0x [meta.rel]p4:
     //   Given the following function prototype:
     //
     //     template <class T>
     //       typename add_rvalue_reference<T>::type create();
     //
     //   the predicate condition for a template specialization
     //   is_convertible<From, To> shall be satisfied if and only if
case BTT_ReferenceConvertsFromTemporary: {
     if (RhsT->isVoidType())
       return LhsT->isVoidType();
 
     // A function definition requires a complete, non-abstract return type.
     if (!Self.isCompleteType(KeyLoc, RhsT) || Self.isAbstractType(KeyLoc, RhsT))
       return false;
 
     // Compute the result of add_rvalue_reference.
-    if (LhsT->isObjectType() || LhsT->isFunctionType())
+    bool RvalueReferenceAdded = false;
+    if (LhsT->isObjectType() || LhsT->isFunctionType()) {
+      RvalueReferenceAdded = true;
       LhsT = Self.Context.getRValueReferenceType(LhsT);
+    }
+
+    if (BTT == BTT_ReferenceConvertsFromTemporary)
+      std::swap(LhsT, RhsT);
 
     // Build a fake source and destination for initialization.
     InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT));
     OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context),
                          Expr::getValueKindForType(LhsT));
     Expr *FromPtr = &From;
     InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc,
                                                            SourceLocation()));
 
     // Perform the initialization in an unevaluated context within a SFINAE
     // trap at translation unit scope.
     EnterExpressionEvaluationContext Unevaluated(
         Self, Sema::ExpressionEvaluationContext::Unevaluated);
     Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true);
     Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl());
     InitializationSequence Init(Self, To, Kind, FromPtr);
     if (Init.Failed())
       return false;
 
     ExprResult Result = Init.Perform(Self, To, Kind, FromPtr);
-    return !Result.isInvalid() && !SFINAE.hasErrorOccurred();
+    if (Result.isInvalid() || SFINAE.hasErrorOccurred())
+      return false;
+
+    if (BTT != clang::BTT_ReferenceConvertsFromTemporary) return true;
+
+    // They're swapped, so we need to consider LhsT and RhsT back-to-front.
+    if (RvalueReferenceAdded || LhsT->isReferenceType())
+      return false;
+
+    QualType UPtr = Self.BuiltinAddPointer(Self.BuiltinRemoveReference(LhsT, UnaryTransformType::RemoveCVRef, {}), {});
+    QualType TPtr = Self.BuiltinAddPointer(Self.BuiltinRemoveReference(RhsT, UnaryTransformType::RemoveCVRef, {}), {});
+    return EvaluateBinaryTypeTrait(Self, TypeTrait::BTT_IsConvertibleTo, UPtr, TPtr, KeyLoc) and Kind.isCopyInit();
   }
 
   case BTT_IsAssignable:
   case BTT_IsNothrowAssignable:
   case BTT_IsTriviallyAssignable: {
     // C++11 [meta.unary.prop]p3:
     //   is_trivially_assignable is defined as:
     //     is_assignable<T, U>::value is true and the assignment, as defined by

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/deprecated-builtins.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct A {};
 
 void f() {
     bool a;
 
-    a = __has_nothrow_assign(A);  // expected-warning-re {{__has_nothrow_assign {{.*}} use __is_nothrow_assignable}}
-    a = __has_nothrow_move_assign(A);  // expected-warning-re {{__has_nothrow_move_assign {{.*}} use __is_nothrow_assignable}}
-    a = __has_nothrow_copy(A);  // expected-warning-re {{__has_nothrow_copy {{.*}} use __is_nothrow_constructible}}
+    a = __has_nothrow_assign(A);  // expected-warning-re {{__has_nothrow_assign {{.*}} use __is_nothrow_copy_assignable}}
+    a = __has_nothrow_move_assign(A);  // expected-warning-re {{__has_nothrow_move_assign {{.*}} use __is_nothrow_move_assignable}}
+    a = __has_nothrow_copy(A);  // expected-warning-re {{__has_nothrow_copy {{.*}} use __is_nothrow_copy_constructible}}
     a = __has_nothrow_constructor(A);  // expected-warning-re {{__has_nothrow_constructor {{.*}} use __is_nothrow_constructible}}
     a = __has_trivial_assign(A);  // expected-warning-re {{__has_trivial_assign {{.*}} use __is_trivially_assignable}}
-    a = __has_trivial_move_assign(A);  // expected-warning-re {{__has_trivial_move_assign {{.*}} use __is_trivially_assignable}}
-    a = __has_trivial_copy(A);  // expected-warning-re {{__has_trivial_copy {{.*}} use __is_trivially_copyable}}
+    a = __has_trivial_move_assign(A);  // expected-warning-re {{__has_trivial_move_assign {{.*}} use __is_trivially_move_assignable}}
+    a = __has_trivial_copy(A);  // expected-warning-re {{__has_trivial_copy {{.*}} use __is_trivially_copy_copyable}}
     a = __has_trivial_constructor(A);  // expected-warning-re {{__has_trivial_constructor {{.*}} use __is_trivially_constructible}}
-    a = __has_trivial_move_constructor(A);  // expected-warning-re {{__has_trivial_move_constructor {{.*}} use __is_trivially_constructible}}
+    a = __has_trivial_move_constructor(A);  // expected-warning-re {{__has_trivial_move_constructor {{.*}} use __is_trivially_move_constructible}}
     a = __has_trivial_destructor(A);  // expected-warning-re {{__has_trivial_destructor {{.*}} use __is_trivially_destructible}}
 
 }

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;
+};
+
+void copy_constructible_checks() {
+  // Builtin types
+
+  { int arr[T(__is_copy_constructible(int))]; }
+  { int arr[T(__is_copy_constructible(const int))]; }
+  { int arr[T(__is_copy_constructible(volatile int))]; }
+  { int arr[T(__is_copy_constructible(const volatile int))]; }
+  { int arr[T(__is_copy_constructible(int&))]; }
+  { int arr[T(__is_copy_constructible(const int&))]; }
+  { int arr[T(__is_copy_constructible(volatile int&))]; }
+  { int arr[T(__is_copy_constructible(const volatile int&))]; }
+  { int arr[F(__is_copy_constructible(int&&))]; }
+  { int arr[F(__is_copy_constructible(const int&&))]; }
+  { int arr[F(__is_copy_constructible(volatile int&&))]; }
+  { int arr[F(__is_copy_constructible(const volatile int&&))]; }
+  { int arr[T(__is_copy_constructible(int*))]; }
+  { int arr[T(__is_copy_constructible(int* const))]; }
+  { int arr[T(__is_copy_constructible(int* volatile))]; }
+  { int arr[T(__is_copy_constructible(int* const volatile))]; }
+  { int arr[F(__is_copy_constructible(int[2]))]; }
+  { int arr[F(__is_copy_constructible(int[]))]; }
+  { int arr[T(__is_copy_constructible(decltype(nullptr)))]; }
+  { int arr[T(__is_copy_constructible(void(*)()))]; }
+  { int arr[T(__is_copy_constructible(void(&)()))]; }
+  { int arr[T(__is_copy_constructible(int Empty::*))]; }
+  { int arr[T(__is_copy_constructible(int (Empty::*)()))]; }
+
+  // // User-defined types
+  { int arr[T(__is_copy_constructible(AllDefaulted))]; };
+  { int arr[T(__is_copy_constructible(const AllDefaulted))]; };
+  { int arr[F(__is_copy_constructible(volatile AllDefaulted))]; };
+  { int arr[F(__is_copy_constructible(const volatile AllDefaulted))]; };
+
+  { int arr[T(__is_copy_constructible(AllDefaulted))]; };
+  { int arr[T(__is_copy_constructible(const AllDefaulted))]; };
+  { int arr[F(__is_copy_constructible(volatile AllDefaulted))]; };
+  { int arr[F(__is_copy_constructible(const volatile AllDefaulted))]; };
+
+  { int arr[T(__is_copy_constructible(CEmptyStruct))]; };
+  { int arr[T(__is_copy_constructible(const CEmptyStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile CEmptyStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile CEmptyStruct))]; };
+
+  { int arr[T(__is_copy_constructible(CppEmptyStruct))]; };
+  { int arr[T(__is_copy_constructible(const CppEmptyStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile CppEmptyStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppEmptyStruct))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardBy2ndVirtBase))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardBy2ndVirtBase))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardBy2ndVirtBase))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardBy2ndVirtBase))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByBase))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByBase))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByBase))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByBase))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByMemb))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByMemb))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByMemb))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByMemb))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByProt))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByProt))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByProt))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByProt))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardBySameBase))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardBySameBase))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardBySameBase))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardBySameBase))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByVirt))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByVirt))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByVirt))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByVirt))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructNonStandardByVirtBase))]; };
+  { int arr[T(__is_copy_constructible(const CppStructNonStandardByVirtBase))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructNonStandardByVirtBase))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructNonStandardByVirtBase))]; };
+
+  { int arr[T(__is_copy_constructible(CppStructStandard))]; };
+  { int arr[T(__is_copy_constructible(const CppStructStandard))]; };
+  { int arr[F(__is_copy_constructible(volatile CppStructStandard))]; };
+  { int arr[F(__is_copy_constructible(const volatile CppStructStandard))]; };
+
+  { int arr[T(__is_copy_constructible(CStruct))]; };
+  { int arr[T(__is_copy_constructible(const CStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile CStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile CStruct))]; };
+
+  { int arr[T(__is_copy_constructible(CVCopyCtor))]; };
+  { int arr[T(__is_copy_constructible(const CVCopyCtor))]; };
+  { int arr[T(__is_copy_constructible(volatile CVCopyCtor))]; };
+  { int arr[T(__is_copy_constructible(const volatile CVCopyCtor))]; };
+
+  { int arr[T(__is_copy_constructible(Derives))]; };
+  { int arr[T(__is_copy_constructible(const Derives))]; };
+  { int arr[F(__is_copy_constructible(volatile Derives))]; };
+  { int arr[F(__is_copy_constructible(const volatile Derives))]; };
+
+  { int arr[T(__is_copy_constructible(DerivesHasRef))]; };
+  { int arr[T(__is_copy_constructible(const DerivesHasRef))]; };
+  { int arr[F(__is_copy_constructible(volatile DerivesHasRef))]; };
+  { int arr[F(__is_copy_constructible(const volatile DerivesHasRef))]; };
+
+  { int arr[T(__is_copy_constructible(Empty))]; };
+  { int arr[T(__is_copy_constructible(const Empty))]; };
+  { int arr[F(__is_copy_constructible(volatile Empty))]; };
+  { int arr[F(__is_copy_constructible(const volatile Empty))]; };
+
+  { int arr[T(__is_copy_constructible(EmptyUnion))]; };
+  { int arr[T(__is_copy_constructible(const EmptyUnion))]; };
+  { int arr[F(__is_copy_constructible(volatile EmptyUnion))]; };
+  { int arr[F(__is_copy_constructible(const volatile EmptyUnion))]; };
+
+  { int arr[T(__is_copy_constructible(Enum))]; };
+  { int arr[T(__is_copy_constructible(const Enum))]; };
+  { int arr[T(__is_copy_constructible(volatile Enum))]; };
+  { int arr[T(__is_copy_constructible(const volatile Enum))]; };
+
+  { int arr[T(__is_copy_constructible(EnumClass))]; };
+  { int arr[T(__is_copy_constructible(const EnumClass))]; };
+  { int arr[T(__is_copy_constructible(volatile EnumClass))]; };
+  { int arr[T(__is_copy_constructible(const volatile EnumClass))]; };
+
+  { int arr[T(__is_copy_constructible(ExtDefaulted))]; };
+  { int arr[T(__is_copy_constructible(const ExtDefaulted))]; };
+  { int arr[F(__is_copy_constructible(volatile ExtDefaulted))]; };
+  { int arr[F(__is_copy_constructible(const volatile ExtDefaulted))]; };
+
+  { int arr[T(__is_copy_constructible(ExtDefaulted))]; };
+  { int arr[T(__is_copy_constructible(const ExtDefaulted))]; };
+  { int arr[F(__is_copy_constructible(volatile ExtDefaulted))]; };
+  { int arr[F(__is_copy_constructible(const volatile ExtDefaulted))]; };
+
+  { int arr[T(__is_copy_constructible(HasCons))]; };
+  { int arr[T(__is_copy_constructible(const HasCons))]; };
+  { int arr[F(__is_copy_constructible(volatile HasCons))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasCons))]; };
+
+  { int arr[T(__is_copy_constructible(HasCopyAssign))]; };
+  { int arr[T(__is_copy_constructible(const HasCopyAssign))]; };
+  { int arr[F(__is_copy_constructible(volatile HasCopyAssign))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasCopyAssign))]; };
+
+  { int arr[T(__is_copy_constructible(HasDest))]; };
+  { int arr[T(__is_copy_constructible(const HasDest))]; };
+  { int arr[F(__is_copy_constructible(volatile HasDest))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasDest))]; };
+
+  { int arr[T(__is_copy_constructible(HasMultipleCopy))]; };
+  { int arr[T(__is_copy_constructible(const HasMultipleCopy))]; };
+  { int arr[F(__is_copy_constructible(volatile HasMultipleCopy))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasMultipleCopy))]; };
+
+  { int arr[T(__is_copy_constructible(HasPriv))]; };
+  { int arr[T(__is_copy_constructible(const HasPriv))]; };
+  { int arr[F(__is_copy_constructible(volatile HasPriv))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasPriv))]; };
+
+  { int arr[T(__is_copy_constructible(HasRef))]; };
+  { int arr[T(__is_copy_constructible(const HasRef))]; };
+  { int arr[F(__is_copy_constructible(volatile HasRef))]; };
+  { int arr[F(__is_copy_constructible(const volatile HasRef))]; };
+
+  { int arr[T(__is_copy_constructible(HasTemplateCons))]; };
+  { int arr[T(__is_copy_constructible(const HasTemplateCons))]; };
+  { int arr[T(__is_copy_constructible(volatile HasTemplateCons))]; };
+  { int arr[T(__is_copy_constructible(const volatile HasTemplateCons))]; };
+
+  { int arr[T(__is_copy_constructible(NoDefaultMoveAssignDueToDtor))]; };
+  { int arr[T(__is_copy_constructible(const NoDefaultMoveAssignDueToDtor))]; };
+  { int arr[F(__is_copy_constructible(volatile NoDefaultMoveAssignDueToDtor))]; };
+  { int arr[F(__is_copy_constructible(const volatile NoDefaultMoveAssignDueToDtor))]; };
+
+  { int arr[T(__is_copy_constructible(NoDefaultMoveAssignDueToUDCopyAssign))]; };
+  { int arr[T(__is_copy_constructible(const NoDefaultMoveAssignDueToUDCopyAssign))]; };
+  { int arr[F(__is_copy_constructible(volatile NoDefaultMoveAssignDueToUDCopyAssign))]; };
+  { int arr[F(__is_copy_constructible(const volatile NoDefaultMoveAssignDueToUDCopyAssign))]; };
+
+  { int arr[T(__is_copy_constructible(NoDefaultMoveAssignDueToUDCopyCtor))]; };
+  { int arr[T(__is_copy_constructible(const NoDefaultMoveAssignDueToUDCopyCtor))]; };
+  { int arr[F(__is_copy_constructible(volatile NoDefaultMoveAssignDueToUDCopyCtor))]; };
+  { int arr[F(__is_copy_constructible(const volatile NoDefaultMoveAssignDueToUDCopyCtor))]; };
+
+  { int arr[T(__is_copy_constructible(NonTCStruct))]; };
+  { int arr[T(__is_copy_constructible(const NonTCStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile NonTCStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile NonTCStruct))]; };
+
+  { int arr[T(__is_copy_constructible(NonTrivialStruct))]; };
+  { int arr[T(__is_copy_constructible(const NonTrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile NonTrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile NonTrivialStruct))]; };
+
+  { int arr[T(__is_copy_constructible(POD))]; };
+  { int arr[T(__is_copy_constructible(const POD))]; };
+  { int arr[F(__is_copy_constructible(volatile POD))]; };
+  { int arr[F(__is_copy_constructible(const volatile POD))]; };
+
+  { int arr[T(__is_copy_constructible(SuperNonTrivialStruct))]; };
+  { int arr[T(__is_copy_constructible(const SuperNonTrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile SuperNonTrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile SuperNonTrivialStruct))]; };
+
+  { int arr[T(__is_copy_constructible(TrivialStruct))]; };
+  { int arr[T(__is_copy_constructible(const TrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(volatile TrivialStruct))]; };
+  { int arr[F(__is_copy_constructible(const volatile TrivialStruct))]; };
+
+  { int arr[T(__is_copy_constructible(Union))]; };
+  { int arr[T(__is_copy_constructible(const Union))]; };
+  { int arr[F(__is_copy_constructible(volatile Union))]; };
+  { int arr[F(__is_copy_constructible(const volatile Union))]; };
+
+
+  { int arr[F(__is_copy_constructible(AllDeleted))]; }
+  { int arr[F(__is_copy_constructible(const AllDeleted))]; }
+  { int arr[F(__is_copy_constructible(volatile AllDeleted))]; }
+  { int arr[F(__is_copy_constructible(const volatile AllDeleted))]; }
+  { int arr[F(__is_copy_constructible(AllPrivate))]; }
+  { int arr[F(__is_copy_constructible(const AllPrivate))]; }
+  { int arr[F(__is_copy_constructible(volatile AllPrivate))]; }
+  { int arr[F(__is_copy_constructible(const volatile AllPrivate))]; }
+  { int arr[F(__is_copy_constructible(AnIncompleteType[]))]; }
+  { int arr[F(__is_copy_constructible(const AnIncompleteType[]))]; }
+  { int arr[F(__is_copy_constructible(volatile AnIncompleteType[]))]; }
+  { int arr[F(__is_copy_constructible(const volatile AnIncompleteType[]))]; }
+  { int arr[F(__is_copy_constructible(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_copy_constructible(const AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_copy_constructible(volatile AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_copy_constructible(const volatile AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_copy_constructible(BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(volatile BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const volatile BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(CopyCtorDeleted))]; }
+  { int arr[F(__is_copy_constructible(const CopyCtorDeleted))]; }
+  { int arr[F(__is_copy_constructible(volatile CopyCtorDeleted))]; }
+  { int arr[F(__is_copy_constructible(const volatile CopyCtorDeleted))]; }
+  { int arr[F(__is_copy_constructible(HasMutableCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const HasMutableCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(volatile HasMutableCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const volatile HasMutableCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(HasMove))]; }
+  { int arr[F(__is_copy_constructible(const HasMove))]; }
+  { int arr[F(__is_copy_constructible(volatile HasMove))]; }
+  { int arr[F(__is_copy_constructible(const volatile HasMove))]; }
+  { int arr[F(__is_copy_constructible(HasMoveAssign))]; }
+  { int arr[F(__is_copy_constructible(const HasMoveAssign))]; }
+  { int arr[F(__is_copy_constructible(volatile HasMoveAssign))]; }
+  { int arr[F(__is_copy_constructible(const volatile HasMoveAssign))]; }
+  { int arr[F(__is_copy_constructible(MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(volatile MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const volatile MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(VirtAr))]; }
+  { int arr[F(__is_copy_constructible(const VirtAr))]; }
+  { int arr[F(__is_copy_constructible(volatile VirtAr))]; }
+  { int arr[F(__is_copy_constructible(const volatile VirtAr))]; }
+  { int arr[F(__is_copy_constructible(VolatileCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const VolatileCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(volatile VolatileCopyCtor))]; }
+  { int arr[F(__is_copy_constructible(const volatile VolatileCopyCtor))]; }
+
+  // Non-referencable types
+  { int arr[F(__is_copy_constructible(void))]; }
+  { int arr[F(__is_copy_constructible(void()))]; }
+}
+
+struct ConstMoveCtor {
+  ConstMoveCtor(const ConstMoveCtor &&);
+};
+
+struct VolatileMoveCtor {
+  VolatileMoveCtor(volatile VolatileMoveCtor &&);
+};
+
+struct CVMoveCtor {
+  CVMoveCtor(const volatile CVMoveCtor &&);
+};
+
+struct MoveCtorDeleted {
+  MoveCtorDeleted(MoveCtorDeleted &&) = delete;
+};
+
+struct BaseDeletedMoveCtor : MoveCtorDeleted {};
+
+struct MemberDeletedMoveCtor {
+  MoveCtorDeleted x;
+};
+
+void move_constructible_checks() {
+  // Builtin types
+  { int arr[T(__is_move_constructible(int))]; }
+  { int arr[T(__is_move_constructible(const int))]; }
+  { int arr[T(__is_move_constructible(volatile int))]; }
+  { int arr[T(__is_move_constructible(const volatile int))]; }
+  { int arr[T(__is_move_constructible(int&))]; }
+  { int arr[T(__is_move_constructible(const int&))]; }
+  { int arr[T(__is_move_constructible(volatile int&))]; }
+  { int arr[T(__is_move_constructible(const volatile int&))]; }
+  { int arr[T(__is_move_constructible(int&&))]; }
+  { int arr[T(__is_move_constructible(const int&&))]; }
+  { int arr[T(__is_move_constructible(volatile int&&))]; }
+  { int arr[T(__is_move_constructible(const volatile int&&))]; }
+  { int arr[T(__is_move_constructible(int*))]; }
+  { int arr[T(__is_move_constructible(int* const))]; }
+  { int arr[T(__is_move_constructible(int* volatile))]; }
+  { int arr[T(__is_move_constructible(int* const volatile))]; }
+  { int arr[F(__is_move_constructible(int[5]))]; }
+  { int arr[F(__is_move_constructible(int[]))]; }
+  { int arr[T(__is_move_constructible(decltype(nullptr)))]; }
+  { int arr[T(__is_move_constructible(void (*)()))]; }
+  { int arr[T(__is_move_constructible(void (&)()))]; }
+  { int arr[T(__is_move_constructible(int Empty::*))]; }
+
+  // // User-defined types
+  { int arr[T(__is_move_constructible(AllDefaulted))]; }
+  { int arr[T(__is_move_constructible(const AllDefaulted))]; }
+  { int arr[F(__is_move_constructible(volatile AllDefaulted))]; }
+  { int arr[F(__is_move_constructible(const volatile AllDefaulted))]; }
+  { int arr[T(__is_move_constructible(AllDefaulted))]; }
+  { int arr[T(__is_move_constructible(const AllDefaulted))]; }
+  { int arr[F(__is_move_constructible(volatile AllDefaulted))]; }
+  { int arr[F(__is_move_constructible(const volatile AllDefaulted))]; }
+  { int arr[T(__is_move_constructible(CEmptyStruct))]; }
+  { int arr[T(__is_move_constructible(const CEmptyStruct))]; }
+  { int arr[F(__is_move_constructible(volatile CEmptyStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile CEmptyStruct))]; }
+  { int arr[T(__is_move_constructible(ConstMoveCtor))]; }
+  { int arr[T(__is_move_constructible(const ConstMoveCtor))]; }
+  { int arr[F(__is_move_constructible(volatile ConstMoveCtor))]; }
+  { int arr[F(__is_move_constructible(const volatile ConstMoveCtor))]; }
+  { int arr[T(__is_move_constructible(CppEmptyStruct))]; }
+  { int arr[T(__is_move_constructible(const CppEmptyStruct))]; }
+  { int arr[F(__is_move_constructible(volatile CppEmptyStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile CppEmptyStruct))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardBy2ndVirtBase))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardBy2ndVirtBase))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardBy2ndVirtBase))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardBy2ndVirtBase))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByBase))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByBase))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByBase))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByBase))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByMemb))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByMemb))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByMemb))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByMemb))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByProt))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByProt))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByProt))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByProt))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardBySameBase))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardBySameBase))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardBySameBase))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardBySameBase))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByVirt))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByVirt))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByVirt))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByVirt))]; }
+  { int arr[T(__is_move_constructible(CppStructNonStandardByVirtBase))]; }
+  { int arr[T(__is_move_constructible(const CppStructNonStandardByVirtBase))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructNonStandardByVirtBase))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructNonStandardByVirtBase))]; }
+  { int arr[T(__is_move_constructible(CppStructStandard))]; }
+  { int arr[T(__is_move_constructible(const CppStructStandard))]; }
+  { int arr[F(__is_move_constructible(volatile CppStructStandard))]; }
+  { int arr[F(__is_move_constructible(const volatile CppStructStandard))]; }
+  { int arr[T(__is_move_constructible(CStruct))]; }
+  { int arr[T(__is_move_constructible(const CStruct))]; }
+  { int arr[F(__is_move_constructible(volatile CStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile CStruct))]; }
+  { int arr[T(__is_move_constructible(CVMoveCtor))]; }
+  { int arr[T(__is_move_constructible(const CVMoveCtor))]; }
+  { int arr[T(__is_move_constructible(volatile CVMoveCtor))]; }
+  { int arr[T(__is_move_constructible(const volatile CVMoveCtor))]; }
+  { int arr[T(__is_move_constructible(Derives))]; }
+  { int arr[T(__is_move_constructible(const Derives))]; }
+  { int arr[F(__is_move_constructible(volatile Derives))]; }
+  { int arr[F(__is_move_constructible(const volatile Derives))]; }
+  { int arr[T(__is_move_constructible(DerivesHasRef))]; }
+  { int arr[T(__is_move_constructible(const DerivesHasRef))]; }
+  { int arr[F(__is_move_constructible(volatile DerivesHasRef))]; }
+  { int arr[F(__is_move_constructible(const volatile DerivesHasRef))]; }
+  { int arr[T(__is_move_constructible(Empty))]; }
+  { int arr[T(__is_move_constructible(const Empty))]; }
+  { int arr[F(__is_move_constructible(volatile Empty))]; }
+  { int arr[F(__is_move_constructible(const volatile Empty))]; }
+  { int arr[T(__is_move_constructible(EmptyUnion))]; }
+  { int arr[T(__is_move_constructible(const EmptyUnion))]; }
+  { int arr[F(__is_move_constructible(volatile EmptyUnion))]; }
+  { int arr[F(__is_move_constructible(const volatile EmptyUnion))]; }
+  { int arr[T(__is_move_constructible(Enum))]; }
+  { int arr[T(__is_move_constructible(const Enum))]; }
+  { int arr[T(__is_move_constructible(volatile Enum))]; }
+  { int arr[T(__is_move_constructible(const volatile Enum))]; }
+  { int arr[T(__is_move_constructible(EnumClass))]; }
+  { int arr[T(__is_move_constructible(const EnumClass))]; }
+  { int arr[T(__is_move_constructible(volatile EnumClass))]; }
+  { int arr[T(__is_move_constructible(const volatile EnumClass))]; }
+  { int arr[T(__is_move_constructible(ExtDefaulted))]; }
+  { int arr[T(__is_move_constructible(const ExtDefaulted))]; }
+  { int arr[F(__is_move_constructible(volatile ExtDefaulted))]; }
+  { int arr[F(__is_move_constructible(const volatile ExtDefaulted))]; }
+  { int arr[T(__is_move_constructible(ExtDefaulted))]; }
+  { int arr[T(__is_move_constructible(const ExtDefaulted))]; }
+  { int arr[F(__is_move_constructible(volatile ExtDefaulted))]; }
+  { int arr[F(__is_move_constructible(const volatile ExtDefaulted))]; }
+  { int arr[T(__is_move_constructible(HasCons))]; }
+  { int arr[T(__is_move_constructible(const HasCons))]; }
+  { int arr[F(__is_move_constructible(volatile HasCons))]; }
+  { int arr[F(__is_move_constructible(const volatile HasCons))]; }
+  { int arr[T(__is_move_constructible(HasCopyAssign))]; }
+  { int arr[T(__is_move_constructible(const HasCopyAssign))]; }
+  { int arr[F(__is_move_constructible(volatile HasCopyAssign))]; }
+  { int arr[F(__is_move_constructible(const volatile HasCopyAssign))]; }
+  { int arr[T(__is_move_constructible(HasDest))]; }
+  { int arr[T(__is_move_constructible(const HasDest))]; }
+  { int arr[F(__is_move_constructible(volatile HasDest))]; }
+  { int arr[F(__is_move_constructible(const volatile HasDest))]; }
+  { int arr[T(__is_move_constructible(HasMove))]; }
+  { int arr[F(__is_move_constructible(const HasMove))]; }
+  { int arr[F(__is_move_constructible(volatile HasMove))]; }
+  { int arr[F(__is_move_constructible(const volatile HasMove))]; }
+  { int arr[T(__is_move_constructible(HasPriv))]; }
+  { int arr[T(__is_move_constructible(const HasPriv))]; }
+  { int arr[F(__is_move_constructible(volatile HasPriv))]; }
+  { int arr[F(__is_move_constructible(const volatile HasPriv))]; }
+  { int arr[T(__is_move_constructible(HasRef))]; }
+  { int arr[T(__is_move_constructible(const HasRef))]; }
+  { int arr[F(__is_move_constructible(volatile HasRef))]; }
+  { int arr[F(__is_move_constructible(const volatile HasRef))]; }
+  { int arr[T(__is_move_constructible(HasTemplateCons))]; }
+  { int arr[T(__is_move_constructible(const HasTemplateCons))]; }
+  { int arr[F(__is_move_constructible(volatile HasTemplateCons))]; }
+  { int arr[F(__is_move_constructible(const volatile HasTemplateCons))]; }
+  { int arr[T(__is_move_constructible(NoDefaultMoveAssignDueToDtor))]; }
+  { int arr[T(__is_move_constructible(const NoDefaultMoveAssignDueToDtor))]; }
+  { int arr[F(__is_move_constructible(volatile NoDefaultMoveAssignDueToDtor))]; }
+  { int arr[F(__is_move_constructible(const volatile NoDefaultMoveAssignDueToDtor))]; }
+  { int arr[T(__is_move_constructible(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int arr[T(__is_move_constructible(const NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int arr[F(__is_move_constructible(volatile NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int arr[F(__is_move_constructible(const volatile NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int arr[T(__is_move_constructible(NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int arr[T(__is_move_constructible(const NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int arr[F(__is_move_constructible(volatile NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int arr[F(__is_move_constructible(const volatile NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int arr[T(__is_move_constructible(NonTCStruct))]; }
+  { int arr[T(__is_move_constructible(const NonTCStruct))]; }
+  { int arr[F(__is_move_constructible(volatile NonTCStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile NonTCStruct))]; }
+  { int arr[T(__is_move_constructible(NonTrivialStruct))]; }
+  { int arr[T(__is_move_constructible(const NonTrivialStruct))]; }
+  { int arr[F(__is_move_constructible(volatile NonTrivialStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile NonTrivialStruct))]; }
+  { int arr[T(__is_move_constructible(POD))]; }
+  { int arr[T(__is_move_constructible(const POD))]; }
+  { int arr[F(__is_move_constructible(volatile POD))]; }
+  { int arr[F(__is_move_constructible(const volatile POD))]; }
+  { int arr[T(__is_move_constructible(SuperNonTrivialStruct))]; }
+  { int arr[T(__is_move_constructible(const SuperNonTrivialStruct))]; }
+  { int arr[F(__is_move_constructible(volatile SuperNonTrivialStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile SuperNonTrivialStruct))]; }
+  { int arr[T(__is_move_constructible(TrivialStruct))]; }
+  { int arr[T(__is_move_constructible(const TrivialStruct))]; }
+  { int arr[F(__is_move_constructible(volatile TrivialStruct))]; }
+  { int arr[F(__is_move_constructible(const volatile TrivialStruct))]; }
+  { int arr[T(__is_move_constructible(Union))]; }
+  { int arr[T(__is_move_constructible(const Union))]; }
+  { int arr[F(__is_move_constructible(volatile Union))]; }
+  { int arr[F(__is_move_constructible(const volatile Union))]; }
+  { int arr[T(__is_move_constructible(VolatileMoveCtor))]; }
+  { int arr[F(__is_move_constructible(const VolatileMoveCtor))]; }
+  { int arr[T(__is_move_constructible(volatile VolatileMoveCtor))]; }
+  { int arr[F(__is_move_constructible(const volatile VolatileMoveCtor))]; }
+
+  { int arr[F(__is_move_constructible(AllDeleted))]; }
+  { int arr[F(__is_move_constructible(AllPrivate))]; }
+  { int arr[F(__is_move_constructible(AnIncompleteType[]))]; }
+  { int arr[F(__is_move_constructible(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int arr[F(__is_move_constructible(BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_move_constructible(BaseDeletedCopyCtor))]; }
+  { int arr[F(__is_move_constructible(BaseDeletedMoveCtor))]; }
+  { int arr[F(__is_move_constructible(CopyCtorDeleted))]; }
+  { int arr[F(__is_move_constructible(CopyCtorDeleted))]; }
+  { int arr[F(__is_move_constructible(CVCopyCtor))]; }
+  { int arr[F(__is_move_constructible(HasMutableCopyCtor))]; }
+  { int arr[F(__is_move_constructible(HasMoveAssign))]; }
+  { int arr[F(__is_move_constructible(MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_move_constructible(MemberDeletedCopyCtor))]; }
+  { int arr[F(__is_move_constructible(MemberDeletedMoveCtor))]; }
+  { int arr[F(__is_move_constructible(MoveCtorDeleted))]; }
+  { int arr[F(__is_move_constructible(VirtAr))]; }
+  { int arr[F(__is_move_constructible(VolatileCopyCtor))]; }
+
+  // Non-referencable types
+  { int arr[F(__is_move_constructible(void))]; }
+  { int arr[F(__is_move_constructible(void()))]; }
+}
+
+struct MutableCopyAssign_QualNone {
+  MutableCopyAssign_QualNone &operator=(MutableCopyAssign_QualNone &);
+};
+struct MutableCopyAssign_QualConst {
+  MutableCopyAssign_QualConst &operator=(MutableCopyAssign_QualConst &) const;
+};
+struct MutableCopyAssign_QualVolatile {
+  MutableCopyAssign_QualVolatile &operator=(MutableCopyAssign_QualVolatile &) volatile;
+};
+struct MutableCopyAssign_QualCV {
+  MutableCopyAssign_QualCV &operator=(MutableCopyAssign_QualCV &) const volatile;
+};
+struct MutableCopyAssign_QualLvalue {
+  MutableCopyAssign_QualLvalue &operator=(MutableCopyAssign_QualLvalue &) &;
+};
+struct MutableCopyAssign_QualConstLvalue {
+  MutableCopyAssign_QualConstLvalue &operator=(MutableCopyAssign_QualConstLvalue &) const &;
+};
+struct MutableCopyAssign_QualVolatileLvalue {
+  MutableCopyAssign_QualVolatileLvalue &operator=(MutableCopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct MutableCopyAssign_QualCVLvalue {
+  MutableCopyAssign_QualCVLvalue &operator=(MutableCopyAssign_QualCVLvalue &) const volatile &;
+};
+struct MutableCopyAssign_QualRvalue {
+  MutableCopyAssign_QualRvalue &operator=(MutableCopyAssign_QualRvalue &) &&;
+};
+struct MutableCopyAssign_QualConstRvalue {
+  MutableCopyAssign_QualConstRvalue &operator=(MutableCopyAssign_QualConstRvalue &) const &&;
+};
+struct MutableCopyAssign_QualVolatileRvalue {
+  MutableCopyAssign_QualVolatileRvalue &operator=(MutableCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct MutableCopyAssign_QualCVRvalue {
+  MutableCopyAssign_QualCVRvalue &operator=(MutableCopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct CopyAssign_QualNone {
+  CopyAssign_QualNone &operator=(const CopyAssign_QualNone &);
+};
+struct CopyAssign_QualConst {
+  CopyAssign_QualConst &operator=(const CopyAssign_QualConst &) const;
+};
+struct CopyAssign_QualVolatile {
+  CopyAssign_QualVolatile &operator=(const CopyAssign_QualVolatile &) volatile;
+};
+struct CopyAssign_QualCV {
+  CopyAssign_QualCV &operator=(const CopyAssign_QualCV &) const volatile;
+};
+struct CopyAssign_QualLvalue {
+  CopyAssign_QualLvalue &operator=(const CopyAssign_QualLvalue &) &;
+};
+struct CopyAssign_QualConstLvalue {
+  CopyAssign_QualConstLvalue &operator=(const CopyAssign_QualConstLvalue &) const &;
+};
+struct CopyAssign_QualVolatileLvalue {
+  CopyAssign_QualVolatileLvalue &operator=(const CopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct CopyAssign_QualCVLvalue {
+  CopyAssign_QualCVLvalue &operator=(const CopyAssign_QualCVLvalue &) const volatile &;
+};
+struct CopyAssign_QualRvalue {
+  CopyAssign_QualRvalue &operator=(const CopyAssign_QualRvalue &) &&;
+};
+struct CopyAssign_QualConstRvalue {
+  CopyAssign_QualConstRvalue &operator=(const CopyAssign_QualConstRvalue &) const &&;
+};
+struct CopyAssign_QualVolatileRvalue {
+  CopyAssign_QualVolatileRvalue &operator=(const CopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct CopyAssign_QualCVRvalue {
+  CopyAssign_QualCVRvalue &operator=(const CopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct VolatileCopyAssign_QualNone {
+  VolatileCopyAssign_QualNone &operator=(volatile VolatileCopyAssign_QualNone &);
+};
+struct VolatileCopyAssign_QualConst {
+  VolatileCopyAssign_QualConst &operator=(volatile VolatileCopyAssign_QualConst &) const;
+};
+struct VolatileCopyAssign_QualVolatile {
+  VolatileCopyAssign_QualVolatile &operator=(volatile VolatileCopyAssign_QualVolatile &) volatile;
+};
+struct VolatileCopyAssign_QualCV {
+  VolatileCopyAssign_QualCV &operator=(volatile VolatileCopyAssign_QualCV &) const volatile;
+};
+struct VolatileCopyAssign_QualLvalue {
+  VolatileCopyAssign_QualLvalue &operator=(volatile VolatileCopyAssign_QualLvalue &) &;
+};
+struct VolatileCopyAssign_QualConstLvalue {
+  VolatileCopyAssign_QualConstLvalue &operator=(volatile VolatileCopyAssign_QualConstLvalue &) const &;
+};
+struct VolatileCopyAssign_QualVolatileLvalue {
+  VolatileCopyAssign_QualVolatileLvalue &operator=(volatile VolatileCopyAssign_QualVolatileLvalue &) volatile &;
+};
+struct VolatileCopyAssign_QualCVLvalue {
+  VolatileCopyAssign_QualCVLvalue &operator=(volatile VolatileCopyAssign_QualCVLvalue &) const volatile &;
+};
+struct VolatileCopyAssign_QualRvalue {
+  VolatileCopyAssign_QualRvalue &operator=(volatile VolatileCopyAssign_QualRvalue &) &&;
+};
+struct VolatileCopyAssign_QualConstRvalue {
+  VolatileCopyAssign_QualConstRvalue &operator=(volatile VolatileCopyAssign_QualConstRvalue &) const &&;
+};
+struct VolatileCopyAssign_QualVolatileRvalue {
+  VolatileCopyAssign_QualVolatileRvalue &operator=(volatile VolatileCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct VolatileCopyAssign_QualCVRvalue {
+  VolatileCopyAssign_QualCVRvalue &operator=(volatile VolatileCopyAssign_QualCVRvalue &) const volatile &&;
+};
+
+struct CVCopyAssign_QualNone {
+  CVCopyAssign_QualNone &operator=(const volatile CVCopyAssign_QualNone &);
+};
+struct CVCopyAssign_QualConst {
+  CVCopyAssign_QualConst &operator=(const volatile CVCopyAssign_QualConst &) const;
+};
+struct CVCopyAssign_QualVolatile {
+  CVCopyAssign_QualVolatile &operator=(const volatile CVCopyAssign_QualVolatile &) volatile;
+};
+struct CVCopyAssign_QualCV {
+  CVCopyAssign_QualCV &operator=(const volatile CVCopyAssign_QualCV &) const volatile;
+};
+struct CVCopyAssign_QualLvalue {
+  CVCopyAssign_QualLvalue &operator=(const volatile CVCopyAssign_QualLvalue &) &;
+};
+struct CVCopyAssign_QualConstLvalue {
+  CVCopyAssign_QualConstLvalue &operator=(const volatile CVCopyAssign_QualConstLvalue &) const &;
+};
+struct CVCopyAssign_QualCVLvalue {
+  CVCopyAssign_QualCVLvalue &operator=(const volatile CVCopyAssign_QualCVLvalue &) volatile &;
+};
+struct CVCopyAssign_QualVolatileLvalue {
+  CVCopyAssign_QualVolatileLvalue &operator=(const volatile CVCopyAssign_QualVolatileLvalue &) const volatile &;
+};
+struct CVCopyAssign_QualRvalue {
+  CVCopyAssign_QualRvalue &operator=(const volatile CVCopyAssign_QualRvalue &) &&;
+};
+struct CVCopyAssign_QualConstRvalue {
+  CVCopyAssign_QualConstRvalue &operator=(const volatile CVCopyAssign_QualConstRvalue &) const &&;
+};
+struct CVCopyAssign_QualVolatileRvalue {
+  CVCopyAssign_QualVolatileRvalue &operator=(const volatile CVCopyAssign_QualVolatileRvalue &) volatile &&;
+};
+struct CVCopyAssign_QualCVRvalue {
+  CVCopyAssign_QualCVRvalue &operator=(const volatile CVCopyAssign_QualCVRvalue &) const volatile &&;
+};
+struct CopyAssignDeleted {
+  CopyAssignDeleted &operator=(const CopyAssignDeleted &) = delete;
+};
+struct BaseDeletedCopyAssign : CopyAssignDeleted {};
+struct HasMemberWithDeletedCopyAssign {
+  CopyAssignDeleted x;
+};
+
+void copy_assignable_checks() {
+  // Builtin types
+  { int a[T(__is_copy_assignable(int))]; }
+  { int a[T(__is_copy_assignable(int &))]; }
+  { int a[T(__is_copy_assignable(int &&))]; }
+  { int a[T(__is_copy_assignable(int *))]; }
+  { int a[F(__is_copy_assignable(int[5]))]; }
+  { int a[F(__is_copy_assignable(int[]))]; }
+  { int a[T(__is_copy_assignable(decltype(nullptr)))]; }
+  { int a[T(__is_copy_assignable(void (*)()))]; }
+  { int a[F(__is_copy_assignable(void (&)()))]; }
+  { int a[T(__is_copy_assignable(int Empty::*))]; }
+  { int a[T(__is_copy_assignable(int (Empty::*)()))]; }
+
+  // // User-defined types
+  { int a[T(__is_copy_assignable(AllDefaulted))]; }
+  { int a[T(__is_copy_assignable(AllDefaulted))]; }
+  { int a[T(__is_copy_assignable(BaseDeletedCopyCtor))]; }
+  { int a[T(__is_copy_assignable(CEmptyStruct))]; }
+  { int a[T(__is_copy_assignable(CopyCtorDeleted))]; }
+  { int a[T(__is_copy_assignable(CppEmptyStruct))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardBy2ndVirtBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByMemb))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByProt))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardBySameBase))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByVirt))]; }
+  { int a[T(__is_copy_assignable(CppStructNonStandardByVirtBase))]; }
+  { int a[T(__is_copy_assignable(CppStructStandard))]; }
+  { int a[T(__is_copy_assignable(CStruct))]; }
+  { int a[T(__is_copy_assignable(CVCopyCtor))]; }
+  { int a[T(__is_copy_assignable(Derives))]; }
+  { int a[T(__is_copy_assignable(DerivesHasCopyAssign))]; }
+  { int a[T(__is_copy_assignable(Empty))]; }
+  { int a[T(__is_copy_assignable(EmptyUnion))]; }
+  { int a[T(__is_copy_assignable(Enum))]; }
+  { int a[T(__is_copy_assignable(EnumClass))]; }
+  { int a[T(__is_copy_assignable(ExtDefaulted))]; }
+  { int a[T(__is_copy_assignable(ExtDefaulted))]; }
+  { int a[T(__is_copy_assignable(HasCons))]; }
+  { int a[T(__is_copy_assignable(HasCopyAssign))]; }
+  { int a[T(__is_copy_assignable(HasDest))]; }
+  { int a[T(__is_copy_assignable(HasMutableCopyCtor))]; }
+  { int a[T(__is_copy_assignable(HasPriv))]; }
+  { int a[T(__is_copy_assignable(HasMultipleCopyAssign))]; }
+  { int a[T(__is_copy_assignable(HasTemplateCons))]; }
+  { int a[T(__is_copy_assignable(MemberDeletedCopyCtor))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToDtor))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int a[T(__is_copy_assignable(NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int a[T(__is_copy_assignable(NonTCStruct))]; }
+  { int a[T(__is_copy_assignable(NonTrivialStruct))]; }
+  { int a[T(__is_copy_assignable(POD))]; }
+  { int a[T(__is_copy_assignable(SuperNonTrivialStruct))]; }
+  { int a[T(__is_copy_assignable(TrivialStruct))]; }
+  { int a[T(__is_copy_assignable(Union))]; }
+
+  { int a[F(__is_copy_assignable(AllDeleted))]; }
+  { int a[F(__is_copy_assignable(AllPrivate))]; }
+  { int a[F(__is_copy_assignable(AnIncompleteType[]))]; }
+  { int a[F(__is_copy_assignable(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int a[F(__is_copy_assignable(DerivesHasRef))]; }
+  { int a[F(__is_copy_assignable(HasRef))]; }
+  { int a[F(__is_copy_assignable(HasMove))]; }
+  { int a[F(__is_copy_assignable(HasMoveAssign))]; }
+  { int a[F(__is_copy_assignable(VirtAr))]; }
+  { int a[F(__is_copy_assignable(CopyAssignDeleted))]; }
+  { int a[F(__is_copy_assignable(BaseDeletedCopyAssign))]; }
+  { int a[F(__is_copy_assignable(HasMemberWithDeletedCopyAssign))]; }
+
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualNone))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConstLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(MutableCopyAssign_QualCVRvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualNone))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualConstLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualVolatileLvalue))]; }
+  { int a[T(__is_copy_assignable(CopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(CopyAssign_QualCVRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualNone))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConstLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(VolatileCopyAssign_QualCVRvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualNone))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualConstLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualVolatileLvalue))]; }
+  { int a[T(__is_copy_assignable(CVCopyAssign_QualCVLvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualConstRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_copy_assignable(CVCopyAssign_QualCVRvalue))]; }
+
+  // Non-referencable types
+  { int a[F(__is_copy_assignable(void))]; }
+  { int a[F(__is_copy_assignable(void()))]; }
+
+  // cv-qualified types
+  { int a[F(__is_copy_assignable(const int))]; }
+  { int a[F(__is_copy_assignable(const Empty))]; }
+  { int a[T(__is_copy_assignable(volatile int))]; }
+  { int a[F(__is_copy_assignable(volatile Empty))]; }
+  { int a[F(__is_copy_assignable(const volatile int))]; }
+  { int a[F(__is_copy_assignable(const volatile Empty))]; }
+
+  { int a[T(__is_copy_assignable(const CopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(volatile CopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(const volatile CopyAssign_QualCV))]; }
+  { int a[F(__is_copy_assignable(const VolatileCopyAssign_QualConst))]; }
+  { int a[F(__is_copy_assignable(volatile VolatileCopyAssign_QualVolatile))]; }
+  { int a[F(__is_copy_assignable(const volatile VolatileCopyAssign_QualCV))]; }
+  { int a[T(__is_copy_assignable(const CVCopyAssign_QualConst))]; }
+  { int a[T(__is_copy_assignable(volatile CVCopyAssign_QualVolatile))]; }
+  { int a[T(__is_copy_assignable(const volatile CVCopyAssign_QualCV))]; }
+}
+
+struct MoveAssign_QualNone {
+  MoveAssign_QualNone &operator=(MoveAssign_QualNone &&);
+};
+struct MoveAssign_QualConst {
+  MoveAssign_QualConst &operator=(MoveAssign_QualConst &&) const;
+};
+struct MoveAssign_QualVolatile {
+  MoveAssign_QualVolatile &operator=(MoveAssign_QualVolatile &&) volatile;
+};
+struct MoveAssign_QualCV {
+  MoveAssign_QualCV &operator=(MoveAssign_QualCV &&) const volatile;
+};
+struct MoveAssign_QualLvalue {
+  MoveAssign_QualLvalue &operator=(MoveAssign_QualLvalue &&) &;
+};
+struct MoveAssign_QualConstLvalue {
+  MoveAssign_QualConstLvalue &operator=(MoveAssign_QualConstLvalue &&) const &;
+};
+struct MoveAssign_QualVolatileLvalue {
+  MoveAssign_QualVolatileLvalue &operator=(MoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct MoveAssign_QualCVLvalue {
+  MoveAssign_QualCVLvalue &operator=(MoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct MoveAssign_QualRvalue {
+  MoveAssign_QualRvalue &operator=(MoveAssign_QualRvalue &&) &&;
+};
+struct MoveAssign_QualConstRvalue {
+  MoveAssign_QualConstRvalue &operator=(MoveAssign_QualConstRvalue &&) const &&;
+};
+struct MoveAssign_QualVolatileRvalue {
+  MoveAssign_QualVolatileRvalue &operator=(MoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct MoveAssign_QualCVRvalue {
+  MoveAssign_QualCVRvalue &operator=(MoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct ConstMoveAssign_QualNone {
+  ConstMoveAssign_QualNone &operator=(const ConstMoveAssign_QualNone &&);
+};
+struct ConstMoveAssign_QualConst {
+  ConstMoveAssign_QualConst &operator=(const ConstMoveAssign_QualConst &&) const;
+};
+struct ConstMoveAssign_QualVolatile {
+  ConstMoveAssign_QualVolatile &operator=(const ConstMoveAssign_QualVolatile &&) volatile;
+};
+struct ConstMoveAssign_QualCV {
+  ConstMoveAssign_QualCV &operator=(const ConstMoveAssign_QualCV &&) const volatile;
+};
+struct ConstMoveAssign_QualLvalue {
+  ConstMoveAssign_QualLvalue &operator=(const ConstMoveAssign_QualLvalue &&) &;
+};
+struct ConstMoveAssign_QualConstLvalue {
+  ConstMoveAssign_QualConstLvalue &operator=(const ConstMoveAssign_QualConstLvalue &&) const &;
+};
+struct ConstMoveAssign_QualVolatileLvalue {
+  ConstMoveAssign_QualVolatileLvalue &operator=(const ConstMoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct ConstMoveAssign_QualCVLvalue {
+  ConstMoveAssign_QualCVLvalue &operator=(const ConstMoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct ConstMoveAssign_QualRvalue {
+  ConstMoveAssign_QualRvalue &operator=(const ConstMoveAssign_QualRvalue &&) &&;
+};
+struct ConstMoveAssign_QualConstRvalue {
+  ConstMoveAssign_QualConstRvalue &operator=(const ConstMoveAssign_QualConstRvalue &&) const &&;
+};
+struct ConstMoveAssign_QualVolatileRvalue {
+  ConstMoveAssign_QualVolatileRvalue &operator=(const ConstMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct ConstMoveAssign_QualCVRvalue {
+  ConstMoveAssign_QualCVRvalue &operator=(const ConstMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct VolatileMoveAssign_QualNone {
+  VolatileMoveAssign_QualNone &operator=(volatile VolatileMoveAssign_QualNone &&);
+};
+struct VolatileMoveAssign_QualConst {
+  VolatileMoveAssign_QualConst &operator=(volatile VolatileMoveAssign_QualConst &&) const;
+};
+struct VolatileMoveAssign_QualVolatile {
+  VolatileMoveAssign_QualVolatile &operator=(volatile VolatileMoveAssign_QualVolatile &&) volatile;
+};
+struct VolatileMoveAssign_QualCV {
+  VolatileMoveAssign_QualCV &operator=(volatile VolatileMoveAssign_QualCV &&) const volatile;
+};
+struct VolatileMoveAssign_QualLvalue {
+  VolatileMoveAssign_QualLvalue &operator=(volatile VolatileMoveAssign_QualLvalue &&) &;
+};
+struct VolatileMoveAssign_QualConstLvalue {
+  VolatileMoveAssign_QualConstLvalue &operator=(volatile VolatileMoveAssign_QualConstLvalue &&) const &;
+};
+struct VolatileMoveAssign_QualVolatileLvalue {
+  VolatileMoveAssign_QualVolatileLvalue &operator=(volatile VolatileMoveAssign_QualVolatileLvalue &&) volatile &;
+};
+struct VolatileMoveAssign_QualCVLvalue {
+  VolatileMoveAssign_QualCVLvalue &operator=(volatile VolatileMoveAssign_QualCVLvalue &&) const volatile &;
+};
+struct VolatileMoveAssign_QualRvalue {
+  VolatileMoveAssign_QualRvalue &operator=(volatile VolatileMoveAssign_QualRvalue &&) &&;
+};
+struct VolatileMoveAssign_QualConstRvalue {
+  VolatileMoveAssign_QualConstRvalue &operator=(volatile VolatileMoveAssign_QualConstRvalue &&) const &&;
+};
+struct VolatileMoveAssign_QualVolatileRvalue {
+  VolatileMoveAssign_QualVolatileRvalue &operator=(volatile VolatileMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct VolatileMoveAssign_QualCVRvalue {
+  VolatileMoveAssign_QualCVRvalue &operator=(volatile VolatileMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+
+struct CVMoveAssign_QualNone {
+  CVMoveAssign_QualNone &operator=(const volatile CVMoveAssign_QualNone &&);
+};
+struct CVMoveAssign_QualConst {
+  CVMoveAssign_QualConst &operator=(const volatile CVMoveAssign_QualConst &&) const;
+};
+struct CVMoveAssign_QualVolatile {
+  CVMoveAssign_QualVolatile &operator=(const volatile CVMoveAssign_QualVolatile &&) volatile;
+};
+struct CVMoveAssign_QualCV {
+  CVMoveAssign_QualCV &operator=(const volatile CVMoveAssign_QualCV &&) const volatile;
+};
+struct CVMoveAssign_QualLvalue {
+  CVMoveAssign_QualLvalue &operator=(const volatile CVMoveAssign_QualLvalue &&) &;
+};
+struct CVMoveAssign_QualConstLvalue {
+  CVMoveAssign_QualConstLvalue &operator=(const volatile CVMoveAssign_QualConstLvalue &&) const &;
+};
+struct CVMoveAssign_QualCVLvalue {
+  CVMoveAssign_QualCVLvalue &operator=(const volatile CVMoveAssign_QualCVLvalue &&) volatile &;
+};
+struct CVMoveAssign_QualVolatileLvalue {
+  CVMoveAssign_QualVolatileLvalue &operator=(const volatile CVMoveAssign_QualVolatileLvalue &&) const volatile &;
+};
+struct CVMoveAssign_QualRvalue {
+  CVMoveAssign_QualRvalue &operator=(const volatile CVMoveAssign_QualRvalue &&) &&;
+};
+struct CVMoveAssign_QualConstRvalue {
+  CVMoveAssign_QualConstRvalue &operator=(const volatile CVMoveAssign_QualConstRvalue &&) const &&;
+};
+struct CVMoveAssign_QualVolatileRvalue {
+  CVMoveAssign_QualVolatileRvalue &operator=(const volatile CVMoveAssign_QualVolatileRvalue &&) volatile &&;
+};
+struct CVMoveAssign_QualCVRvalue {
+  CVMoveAssign_QualCVRvalue &operator=(const volatile CVMoveAssign_QualCVRvalue &&) const volatile &&;
+};
+struct MoveAssignDeleted {
+  MoveAssignDeleted &operator=(const MoveAssignDeleted &&) = delete;
+};
+struct BaseDeletedMoveAssign : MoveAssignDeleted {};
+struct HasMemberWithDeletedMoveAssign {
+  MoveAssignDeleted x;
+};
+
+void move_assignable_checks() {
+  // Builtin types
+  { int a[T(__is_move_assignable(int))]; }
+  { int a[T(__is_move_assignable(int &))]; }
+  { int a[T(__is_move_assignable(int &&))]; }
+  { int a[T(__is_move_assignable(int *))]; }
+  { int a[F(__is_move_assignable(int[5]))]; }
+  { int a[F(__is_move_assignable(int[]))]; }
+  { int a[T(__is_move_assignable(decltype(nullptr)))]; }
+  { int a[T(__is_move_assignable(void (*)()))]; }
+  { int a[F(__is_move_assignable(void (&)()))]; }
+  { int a[T(__is_move_assignable(int Empty::*))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)()))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile &))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() volatile &&))]; }
+  { int a[T(__is_move_assignable(int(Empty::*)() const volatile &&))]; }
+
+  // // User-defined types
+  { int a[T(__is_move_assignable(AllDefaulted))]; }
+  { int a[T(__is_move_assignable(AllDefaulted))]; }
+  { int a[T(__is_move_assignable(BaseDeletedCopyCtor))]; }
+  { int a[T(__is_move_assignable(CEmptyStruct))]; }
+  { int a[T(__is_move_assignable(CopyCtorDeleted))]; }
+  { int a[T(__is_move_assignable(CppEmptyStruct))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardBy2ndVirtBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByMemb))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByProt))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardBySameBase))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByVirt))]; }
+  { int a[T(__is_move_assignable(CppStructNonStandardByVirtBase))]; }
+  { int a[T(__is_move_assignable(CppStructStandard))]; }
+  { int a[T(__is_move_assignable(CStruct))]; }
+  { int a[T(__is_move_assignable(CVCopyCtor))]; }
+  { int a[T(__is_move_assignable(Derives))]; }
+  { int a[T(__is_move_assignable(DerivesHasCopyAssign))]; }
+  { int a[T(__is_move_assignable(Empty))]; }
+  { int a[T(__is_move_assignable(EmptyUnion))]; }
+  { int a[T(__is_move_assignable(Enum))]; }
+  { int a[T(__is_move_assignable(EnumClass))]; }
+  { int a[T(__is_move_assignable(ExtDefaulted))]; }
+  { int a[T(__is_move_assignable(ExtDefaulted))]; }
+  { int a[T(__is_move_assignable(HasCons))]; }
+  { int a[T(__is_move_assignable(HasCopyAssign))]; }
+  { int a[T(__is_move_assignable(HasDest))]; }
+  { int a[T(__is_move_assignable(HasMutableCopyCtor))]; }
+  { int a[T(__is_move_assignable(HasPriv))]; }
+  { int a[T(__is_move_assignable(HasMultipleCopyAssign))]; }
+  { int a[T(__is_move_assignable(HasTemplateCons))]; }
+  { int a[T(__is_move_assignable(MemberDeletedCopyCtor))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToDtor))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToUDCopyAssign))]; }
+  { int a[T(__is_move_assignable(NoDefaultMoveAssignDueToUDCopyCtor))]; }
+  { int a[T(__is_move_assignable(NonTCStruct))]; }
+  { int a[T(__is_move_assignable(NonTrivialStruct))]; }
+  { int a[T(__is_move_assignable(POD))]; }
+  { int a[T(__is_move_assignable(SuperNonTrivialStruct))]; }
+  { int a[T(__is_move_assignable(TrivialStruct))]; }
+  { int a[T(__is_move_assignable(Union))]; }
+  { int a[T(__is_move_assignable(HasMoveAssign))]; }
+
+  { int a[F(__is_move_assignable(AllDeleted))]; }
+  { int a[F(__is_move_assignable(AllPrivate))]; }
+  { int a[F(__is_move_assignable(AnIncompleteType[]))]; }
+  { int a[F(__is_move_assignable(AnIncompleteType))]; } // expected-error{{incomplete type}}
+  { int a[F(__is_move_assignable(DerivesHasRef))]; }
+  { int a[F(__is_move_assignable(HasRef))]; }
+  { int a[F(__is_move_assignable(HasMove))]; }
+  { int a[F(__is_move_assignable(VirtAr))]; }
+  { int a[F(__is_move_assignable(MoveAssignDeleted))]; }
+  { int a[F(__is_move_assignable(BaseDeletedMoveAssign))]; }
+  { int a[F(__is_move_assignable(HasMemberWithDeletedMoveAssign))]; }
+
+  { int a[T(__is_move_assignable(MoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(MoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(MoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(ConstMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(ConstMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(ConstMoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(VolatileMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(VolatileMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(VolatileMoveAssign_QualCVRvalue))]; }
+  { int a[T(__is_move_assignable(CVMoveAssign_QualNone))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(CVMoveAssign_QualLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConstLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatileLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCVLvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualConstRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualVolatileRvalue))]; }
+  { int a[F(__is_move_assignable(CVMoveAssign_QualCVRvalue))]; }
+
+  // Non-referencable types
+  { int a[F(__is_move_assignable(void))]; }
+  { int a[F(__is_move_assignable(void()))]; }
+
+  // cv-qualified types
+  { int a[F(__is_move_assignable(const int))]; }
+  { int a[F(__is_move_assignable(const Empty))]; }
+  { int a[T(__is_move_assignable(volatile int))]; }
+  { int a[F(__is_move_assignable(volatile Empty))]; }
+  { int a[F(__is_move_assignable(const volatile int))]; }
+  { int a[F(__is_move_assignable(const volatile Empty))]; }
+
+  { int a[F(__is_move_assignable(const MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(volatile MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(const volatile MoveAssign_QualConst))]; }
+  { int a[F(__is_move_assignable(volatile MoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(const volatile MoveAssign_QualCV))]; }
+  { int a[F(__is_move_assignable(const VolatileMoveAssign_QualConst))]; }
+  { int a[T(__is_move_assignable(volatile VolatileMoveAssign_QualVolatile))]; }
+  { int a[F(__is_move_assignable(const volatile VolatileMoveAssign_QualCV))]; }
+  { int a[T(__is_move_assignable(const CVMoveAssign_QualConst))]; }
+  { int a[T(__is_move_assignable(volatile CVMoveAssign_QualVolatile))]; }
+  { int a[T(__is_move_assignable(const volatile CVMoveAssign_QualCV))]; }
+}
+
 // Instantiation of __is_trivially_constructible
 template<typename T, typename ...Args>
 struct is_trivially_constructible {
   static const bool value = __is_trivially_constructible(T, Args...);
 };
 
 void is_trivially_constructible_test() {
   { int arr[T((is_trivially_constructible<int>::value))]; }
void reference_binds_to_temporary_checks() {
   { int arr[T((__reference_binds_to_temporary(int const &, LongRef)))]; }
 
   // Test that it doesn't accept non-reference types as input.
   { int arr[F((__reference_binds_to_temporary(int, long)))]; }
 
   { int arr[T((__reference_binds_to_temporary(const int &, long)))]; }
 }
 
+void reference_constructs_from_temporary_checks() {
+  { int arr[F((__reference_constructs_from_temporary(int &, int &)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int &, int &&)))]; }
+
+  { int arr[F((__reference_constructs_from_temporary(int const &, int &)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int const &, int const &)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int const &, int &&)))]; }
+
+  { int arr[F((__reference_constructs_from_temporary(int &, long &)))]; } // doesn't construct
+
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_constructs_from_temporary(int const &, long &)))]; }
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_constructs_from_temporary(int const &, long &&)))]; }
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_constructs_from_temporary(int &&, long &)))]; }
+
+  using LRef = ConvertsToRef<int, int &>;
+  using RRef = ConvertsToRef<int, int &&>;
+  using CLRef = ConvertsToRef<int, const int &>;
+  using LongRef = ConvertsToRef<long, long &>;
+  { int arr[T((__is_constructible(int &, LRef)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int &, LRef)))]; }
+
+  { int arr[T((__is_constructible(int &&, RRef)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int &&, RRef)))]; }
+
+  { int arr[T((__is_constructible(int const &, CLRef)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int &&, CLRef)))]; }
+
+  { int arr[T((__is_constructible(int const &, LongRef)))]; }
+  { int arr[F((__reference_constructs_from_temporary(int const &, LongRef)))]; }
+
+  // Test that it doesn't accept non-reference types as input.
+  { int arr[F((__reference_constructs_from_temporary(int, long)))]; }
+
+  { int arr[F((__reference_constructs_from_temporary(const int &, long)))]; }
+
+  // Additional checks
+  { int arr[T((__reference_constructs_from_temporary(int&&, int)))]; }
+  { int arr[T((__reference_constructs_from_temporary(POD const&, Derives)))]; }
+}
+
+void reference_converts_from_temporary_checks() {
+  { int arr[F((__reference_converts_from_temporary(int &, int &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int &, int &&)))]; }
+
+  { int arr[F((__reference_converts_from_temporary(int const &, int &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int const &, int const &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int const &, int &&)))]; }
+
+  { int arr[F((__reference_converts_from_temporary(int &, long &)))]; } // doesn't construct
+
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_converts_from_temporary(int const &, long &)))]; }
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_converts_from_temporary(int const &, long &&)))]; }
+  // Diverges from __reference_binds_to_temporary
+  { int arr[F((__reference_converts_from_temporary(int &&, long &)))]; }
+
+  using LRef = ConvertsToRef<int, int &>;
+  using RRef = ConvertsToRef<int, int &&>;
+  using CLRef = ConvertsToRef<int, const int &>;
+  using LongRef = ConvertsToRef<long, long &>;
+  { int arr[T((__is_convertible(LRef, int &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int &, LRef)))]; }
+
+  { int arr[T((__is_convertible(RRef, int &&)))]; }
+  { int arr[F((__reference_converts_from_temporary(int &&, RRef)))]; }
+
+  { int arr[T((__is_convertible(CLRef, int const &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int &&, CLRef)))]; }
+
+  { int arr[T((__is_convertible(LongRef, int const &)))]; }
+  { int arr[F((__reference_converts_from_temporary(int const &, LongRef)))]; }
+
+  // Test that it doesn't accept non-reference types as input.
+  { int arr[F((__reference_converts_from_temporary(int, long)))]; }
+
+  { int arr[F((__reference_converts_from_temporary(const int &, long)))]; }
+
+  // Additional checks
+  { int arr[T((__reference_converts_from_temporary(int&&, int)))]; }
+  { int arr[T((__reference_converts_from_temporary(POD const&, Derives)))]; }
+}
+
 void array_rank() {
   int t01[T(__array_rank(IntAr) == 1)];
   int t02[T(__array_rank(ConstIntArAr) == 2)];
 }
 
 void array_extent() {
   int t01[T(__array_extent(IntAr, 0) == 10)];
   int t02[T(__array_extent(ConstIntArAr, 0) == 4)];
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; }