[clang] adds copy-constructible type-trait builtins

[cjdb]

Summary

• __is_copy_constructible
• __is_nothrow_copy_constructible
• __is_trivially_copy_constructible

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

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

This was originally a part of D116280.

Depends on D135177.

[cjdb]

Restarts CI

[cjdb]

rewords commit message

[erichkeane]

Please make sure these are going to be OK with libc++ here. "Triviality" is a bit of a hard nut, the standards have re-defined what they mean quite a few times, so this ends up being pretty worthless if it doesn't match the 'version' of this check that the library is trying to look at.

clang/include/clang/Basic/TokenKinds.def

528

So this one is a whole 'thing'. The Clang definition of 'trivially copy constructible' is a few DRs behind. We should probably discuss this with libcxx to make sure use of this wouldn't be broken.

[philnik]

TBH I don't think adding these builtins is worth the extra maintenance cost. libc++'s implementation is already really simple, and actually uses __is_constructible, contrary to the statement in the summary. This is the whole implementation currently:

template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
    : public integral_constant<
          bool,
          __is_constructible(_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};

#if _LIBCPP_STD_VER > 14
template <class _Tp>
inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
#endif

I don't think adding an extra #if __has_builtin(...) is worth it in this case, since we already use builtins for most of it. IMO the effort would be better spent adding a builtin for add_const; that would probably make the implementation about as efficient as adding a builtin specifically for is_copy_constructible. It would effectively just be __is_constructible(_Tp, __add_lvalue_reference(__add_const(_Tp))). The trivially and nothrow versions look very similar, just with __is_trivially_constructible and __is_nothrow_constructible respectively.

[cjdb]

clang/include/clang/Basic/TokenKinds.def

528

I'd prefer to get those DRs in before finalising D135238 and subsequent ones. Do you know the DR numbers I should be looking at, or should I just poke npaperbot?

[erichkeane]

clang/include/clang/Basic/TokenKinds.def

528

Not off the top of my head, Aaron and I both poked at it at one point trying to get trivially constructible right at one point, but I think we both gave up due to the ABI/versioning concerns.

[royjacobson]

clang/include/clang/Basic/TokenKinds.def

528

Maybe DR1734? Although it's about the trivially copyable trait, not trivially copy constructible.

[erichkeane]

clang/include/clang/Basic/TokenKinds.def

528

Yeah, I think that was the DR, that number sounds familiar.

[cjdb]

clang/include/clang/Basic/TokenKinds.def

528

The __is_trivially_* traits were, in part, what inspired the Great Split of D116208. I could remove them for now and revisit once I rip my hair out over these DRs, if that would substantially improve the chances of these commits landing (other commentary notwithstanding).

[ldionne]

clang/include/clang/Basic/TokenKinds.def

528

I am not sure I see a problem with the "triviality" part of this -- we already use a compiler builtin for std::is_trivially_constructible, so I would expect either this patch is fine, or we already have a latent bug in libc++.

I think I can echo @philnik's comment about this not necessarily providing the biggest benefit since our implementation of std::is_trivially_copy_constructible is a fairly trivial wrapper on top of __is_trivially_constructible, but I wouldn't object to the patch on that basis. I think it would probably be possible to instead provide a set of basis builtin operations that we can then build all of the library type traits on top of -- that would provide the highest bang-for-our-buck ratio.

At the same time, there's something kind of enticing in the consistency of defining every single type trait as a builtin, without exception. If that's the end goal, I think that would also be neat and we'd likely regroup all of our type traits under a single header, since each of them would literally be a one liner.

There's also the question of whether GCC provides these builtins -- if they don't and if they don't have plans to, then we'd actually need to add complexity in libc++ to support both, which we would be unlikely to do given that there's probably not a huge compile-time performance benefit.

TLDR, I think the two questions that can help gauge how much interest there will be from libc++ to use this are:

1. Is the plan to provide *all* the type traits as builtins?
2. Will GCC implement them?

That being said, libc++ might not be the only potential user of these builtins, so I wouldn't necessarily make it a hard requirement to satisfy us.

[cjdb]

clang/include/clang/Basic/TokenKinds.def

528

I think I can echo @philnik's comment about this not necessarily providing the biggest benefit since our implementation of std::is_trivially_copy_constructible is a fairly trivial wrapper on top of __is_trivially_constructible, but I wouldn't object to the patch on that basis.

I haven't had time to do anything properly in the way of benchmarking, but after looking at @philnik's quoted code, I see that I'd naively addressed __is_constructible(T, T const&), forgetting that __add_lvalue_reference would've fixed that issue.

1. Is the plan to provide *all* the type traits as builtins?

Yes, with the possible exception of enable_if and add_const etc. (see D116203 for why the qualifier ones aren't already in). The hardest ones will probably be common_type, common_reference, *invocable*, and *swappable*. The former two depend on technology that doesn't exist in Clang yet, and the latter two are likely hard due there not being prior art.

2. Will GCC implement them?

@jwakely do you know if there can be cross-compiler synergy here?

[jwakely]

clang/include/clang/Basic/TokenKinds.def

528

Which traits are you asking about, just the __is_{,trivially,nothrow}_copy_constructible ones? Or all type traits?

Either way, I think the answer is no. We already use __is_{,trivially,nothrow}_constructible for the copy-constructible traits, and it works fine. I'm not aware of any problems with it. So I don't see any benefit in adding these ones. As already mentioned, it creates *more* code to maintain when using these traits, because we still have to support older versions of other compilers that don't have all the new traits yet.

We've added traits for a few more things recently (__remove_cv, __remove_cvref, __remove_reference) but they can only be used in limited ways (you can't use them directly to implement std::remove_cv_t for example, because they don't mangle to the same thing, which is observable). So I'm sceptical about the benefits of implementing *every* trait as a built-in. There are some which are bottlenecks and worth doing, and some which aren't.

[cjdb]

clang/include/clang/Basic/TokenKinds.def

528

Which traits are you asking about, just the __is_{,trivially,nothrow}_copy_constructible ones? Or all type traits?

Either way, I think the answer is no. We already use __is_{,trivially,nothrow}_constructible for the copy-constructible traits, and it works fine. I'm not aware of any problems with it. So I don't see any benefit in adding these ones. As already mentioned, it creates *more* code to maintain when using these traits, because we still have to support older versions of other compilers that don't have all the new traits yet.

Thanks for filling in the knowledge-gap here. I think libc++ only supports the most recent two releases of Clang (and I think only the latest release of GCC), so that library code would have an expiration date of around most eighteen months. So I'm clearer on the libstdc++ side of things, how far back do you normally support?

We've added traits for a few more things recently (__remove_cv, __remove_cvref, __remove_reference) but they can only be used in limited ways (you can't use them directly to implement std::remove_cv_t for example, because they don't mangle to the same thing, which is observable).

Interesting. Is this a libstdc++ backwards-compat issue, or does it burrow into the Itanium ABI, which has mangling conventions for builtin type transformers?

[cjdb]

Abandoning, since this doesn't have consensus.

[cjdb]

runs 'arc diff git merge-base HEAD origin --update D135238' to try and get CI happy

clang/include/clang/Basic/TokenKinds.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_1(__is_copy_constructible, IsCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_nothrow_copy_constructible, IsNothrowCopyConstructible, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_copy_constructible, IsTriviallyCopyConstructible, KEYCXX)
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
 
 // Embarcadero Unary Type Traits
 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)

clang/lib/Parse/ParseDeclCXX.cpp

#include "clang/Basic/TransformTypeTraits.def"
           tok::kw___is_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_convertible,
           tok::kw___is_convertible_to,
           tok::kw___is_destructible,
           tok::kw___is_empty,
           tok::kw___is_enum,
           tok::kw___is_floating_point,
           tok::kw___is_final,
           tok::kw___is_function,
           tok::kw___is_fundamental,
           tok::kw___is_integral,
           tok::kw___is_interface_class,
           tok::kw___is_literal,
           tok::kw___is_lvalue_expr,
           tok::kw___is_lvalue_reference,
           tok::kw___is_member_function_pointer,
           tok::kw___is_member_object_pointer,
           tok::kw___is_member_pointer,
           tok::kw___is_nothrow_assignable,
           tok::kw___is_nothrow_constructible,
+          tok::kw___is_nothrow_copy_constructible,
           tok::kw___is_nothrow_destructible,
           tok::kw___is_nullptr,
           tok::kw___is_object,
           tok::kw___is_pod,
           tok::kw___is_pointer,
           tok::kw___is_polymorphic,
           tok::kw___is_reference,
           tok::kw___is_referenceable,
           tok::kw___is_rvalue_expr,
           tok::kw___is_rvalue_reference,
           tok::kw___is_same,
           tok::kw___is_scalar,
           tok::kw___is_scoped_enum,
           tok::kw___is_sealed,
           tok::kw___is_signed,
           tok::kw___is_standard_layout,
           tok::kw___is_trivial,
           tok::kw___is_trivially_assignable,
           tok::kw___is_trivially_constructible,
+          tok::kw___is_trivially_copy_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

clang/lib/Parse/ParseExpr.cpp

#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           REVERTIBLE_TYPE_TRAIT(__is_bounded_array);
           REVERTIBLE_TYPE_TRAIT(__is_class);
           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
           REVERTIBLE_TYPE_TRAIT(__is_compound);
           REVERTIBLE_TYPE_TRAIT(__is_const);
           REVERTIBLE_TYPE_TRAIT(__is_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_convertible_to);
           REVERTIBLE_TYPE_TRAIT(__is_convertible);
+          REVERTIBLE_TYPE_TRAIT(__is_copy_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_destructible);
           REVERTIBLE_TYPE_TRAIT(__is_empty);
           REVERTIBLE_TYPE_TRAIT(__is_enum);
           REVERTIBLE_TYPE_TRAIT(__is_final);
           REVERTIBLE_TYPE_TRAIT(__is_floating_point);
           REVERTIBLE_TYPE_TRAIT(__is_function);
           REVERTIBLE_TYPE_TRAIT(__is_fundamental);
           REVERTIBLE_TYPE_TRAIT(__is_integral);
           REVERTIBLE_TYPE_TRAIT(__is_interface_class);
           REVERTIBLE_TYPE_TRAIT(__is_literal);
           REVERTIBLE_TYPE_TRAIT(__is_lvalue_expr);
           REVERTIBLE_TYPE_TRAIT(__is_lvalue_reference);
           REVERTIBLE_TYPE_TRAIT(__is_member_function_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_member_object_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_member_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_constructible);
+          REVERTIBLE_TYPE_TRAIT(__is_nothrow_copy_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_destructible);
           REVERTIBLE_TYPE_TRAIT(__is_nullptr);
           REVERTIBLE_TYPE_TRAIT(__is_object);
           REVERTIBLE_TYPE_TRAIT(__is_pod);
           REVERTIBLE_TYPE_TRAIT(__is_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_polymorphic);
           REVERTIBLE_TYPE_TRAIT(__is_reference);
           REVERTIBLE_TYPE_TRAIT(__is_referenceable);
           REVERTIBLE_TYPE_TRAIT(__is_rvalue_expr);
           REVERTIBLE_TYPE_TRAIT(__is_rvalue_reference);
           REVERTIBLE_TYPE_TRAIT(__is_same);
           REVERTIBLE_TYPE_TRAIT(__is_scalar);
           REVERTIBLE_TYPE_TRAIT(__is_scoped_enum);
           REVERTIBLE_TYPE_TRAIT(__is_sealed);
           REVERTIBLE_TYPE_TRAIT(__is_signed);
           REVERTIBLE_TYPE_TRAIT(__is_standard_layout);
           REVERTIBLE_TYPE_TRAIT(__is_trivial);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
+          REVERTIBLE_TYPE_TRAIT(__is_trivially_copy_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));

clang/lib/Sema/SemaExprCXX.cpp

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:
     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
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: {
+    if (T->isIncompleteArrayType())
+      return false;
+    if (!T.isReferenceable())
+      return false;
+
+    QualType AssigneeType = T;
+    AssigneeType.addConst();
+    AssigneeType = Self.BuiltinAddReference(
+        AssigneeType, UnaryTransformType::AddLvalueReference, 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_IsReferenceable:
     return T.isReferenceable();
   }
 }
 
 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
                                     QualType RhsT, SourceLocation KeyLoc);
 
void DiagnoseBuiltinDeprecation(Sema& S, TypeTrait Kind,
                                 SourceLocation KWLoc) {
   TypeTrait Replacement;
   switch (Kind) {
     case UTT_HasNothrowAssign:
     case UTT_HasNothrowMoveAssign:
       Replacement = BTT_IsNothrowAssignable;
       break;
     case UTT_HasNothrowCopy:
+      Replacement = UTT_IsNothrowCopyConstructible;
+      break;
     case UTT_HasNothrowConstructor:
       Replacement = TT_IsNothrowConstructible;
       break;
     case UTT_HasTrivialAssign:
     case UTT_HasTrivialMoveAssign:
       Replacement = BTT_IsTriviallyAssignable;
       break;
     case UTT_HasTrivialCopy:
-      Replacement = UTT_IsTriviallyCopyable;
+      Replacement = UTT_IsTriviallyCopyConstructible;
       break;
     case UTT_HasTrivialDefaultConstructor:
     case UTT_HasTrivialMoveConstructor:
       Replacement = TT_IsTriviallyConstructible;
       break;
     case UTT_HasTrivialDestructor:
       Replacement = UTT_IsTriviallyDestructible;
       break;

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_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_copy(A);  // expected-warning-re {{__has_trivial_copy {{.*}} use __is_trivially_copy_constructible}}
     a = __has_trivial_constructor(A);  // expected-warning-re {{__has_trivial_constructor {{.*}} use __is_trivially_constructible}}
     a = __has_trivial_move_constructor(A);  // expected-warning-re {{__has_trivial_move_constructor {{.*}} use __is_trivially_constructible}}
     a = __has_trivial_destructor(A);  // expected-warning-re {{__has_trivial_destructor {{.*}} use __is_trivially_destructible}}
 
 }

clang/test/SemaCXX/type-traits.cpp

void 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;
+};
+
+struct NothrowCopyConstructible {
+  NothrowCopyConstructible(NothrowCopyConstructible const&) noexcept;
+};
+
+void copy_constructible_checks() {
+  // Builtin types
+
+  static_assert(__is_copy_constructible(int), "");
+  static_assert(__is_nothrow_copy_constructible(int), "");
+  static_assert(__is_trivially_copy_constructible(int), "");
+
+  static_assert(__is_copy_constructible(const int), "");
+  static_assert(__is_nothrow_copy_constructible(const int), "");
+  static_assert(__is_trivially_copy_constructible(const int), "");
+
+  static_assert(__is_copy_constructible(volatile int), "");
+  static_assert(__is_nothrow_copy_constructible(volatile int), "");
+  static_assert(__is_trivially_copy_constructible(volatile int), "");
+
+  static_assert(__is_copy_constructible(const volatile int), "");
+  static_assert(__is_nothrow_copy_constructible(const volatile int), "");
+  static_assert(__is_trivially_copy_constructible(const volatile int), "");
+
+  static_assert(__is_copy_constructible(int&), "");
+  static_assert(__is_nothrow_copy_constructible(int&), "");
+  static_assert(__is_trivially_copy_constructible(int&), "");
+
+  static_assert(__is_copy_constructible(const int&), "");
+  static_assert(__is_nothrow_copy_constructible(const int&), "");
+  static_assert(__is_trivially_copy_constructible(const int&), "");
+
+  static_assert(__is_copy_constructible(volatile int&), "");
+  static_assert(__is_nothrow_copy_constructible(volatile int&), "");
+  static_assert(__is_trivially_copy_constructible(volatile int&), "");
+
+  static_assert(__is_copy_constructible(const volatile int&), "");
+  static_assert(__is_nothrow_copy_constructible(const volatile int&), "");
+  static_assert(__is_trivially_copy_constructible(const volatile int&), "");
+
+  static_assert(!__is_copy_constructible(int&&), "");
+  static_assert(!__is_nothrow_copy_constructible(int&&), "");
+  static_assert(!__is_trivially_copy_constructible(int&&), "");
+
+  static_assert(!__is_copy_constructible(const int&&), "");
+  static_assert(!__is_nothrow_copy_constructible(const int&&), "");
+  static_assert(!__is_trivially_copy_constructible(const int&&), "");
+
+  static_assert(!__is_copy_constructible(volatile int&&), "");
+  static_assert(!__is_nothrow_copy_constructible(volatile int&&), "");
+  static_assert(!__is_trivially_copy_constructible(volatile int&&), "");
+
+  static_assert(!__is_copy_constructible(const volatile int&&), "");
+  static_assert(!__is_nothrow_copy_constructible(const volatile int&&), "");
+  static_assert(!__is_trivially_copy_constructible(const volatile int&&), "");
+
+  static_assert(__is_copy_constructible(int*), "");
+  static_assert(__is_nothrow_copy_constructible(int*), "");
+  static_assert(__is_trivially_copy_constructible(int*), "");
+
+  static_assert(__is_copy_constructible(int* const), "");
+  static_assert(__is_nothrow_copy_constructible(int* const), "");
+  static_assert(__is_trivially_copy_constructible(int* const), "");
+
+  static_assert(__is_copy_constructible(int* volatile), "");
+  static_assert(__is_nothrow_copy_constructible(int* volatile), "");
+  static_assert(__is_trivially_copy_constructible(int* volatile), "");
+
+  static_assert(__is_copy_constructible(int* const volatile), "");
+  static_assert(__is_nothrow_copy_constructible(int* const volatile), "");
+  static_assert(__is_trivially_copy_constructible(int* const volatile), "");
+
+  static_assert(!__is_copy_constructible(int[2]), "");
+  static_assert(!__is_nothrow_copy_constructible(int[2]), "");
+  static_assert(!__is_trivially_copy_constructible(int[2]), "");
+
+  static_assert(!__is_copy_constructible(int[]), "");
+  static_assert(!__is_nothrow_copy_constructible(int[]), "");
+  static_assert(!__is_trivially_copy_constructible(int[]), "");
+
+  static_assert(__is_copy_constructible(decltype(nullptr)), "");
+  static_assert(__is_nothrow_copy_constructible(decltype(nullptr)), "");
+  static_assert(__is_trivially_copy_constructible(decltype(nullptr)), "");
+
+  static_assert(__is_copy_constructible(void(*)()), "");
+  static_assert(__is_nothrow_copy_constructible(void(*)()), "");
+  static_assert(__is_trivially_copy_constructible(void(*)()), "");
+
+  static_assert(__is_copy_constructible(void(&)()), "");
+  static_assert(__is_nothrow_copy_constructible(void(&)()), "");
+  static_assert(__is_trivially_copy_constructible(void(&)()), "");
+
+  static_assert(__is_copy_constructible(int Empty::*), "");
+  static_assert(__is_nothrow_copy_constructible(int Empty::*), "");
+  static_assert(__is_trivially_copy_constructible(int Empty::*), "");
+
+  static_assert(__is_copy_constructible(int (Empty::*)()), "");
+  static_assert(__is_nothrow_copy_constructible(int (Empty::*)()), "");
+  static_assert(__is_trivially_copy_constructible(int (Empty::*)()), "");
+
+  // User-defined types
+  static_assert(__is_copy_constructible(AllDefaulted), "");
+  static_assert(__is_nothrow_copy_constructible(AllDefaulted), "");
+  static_assert(__is_trivially_copy_constructible(AllDefaulted), "");
+
+  static_assert(__is_copy_constructible(const AllDefaulted), "");
+  static_assert(__is_nothrow_copy_constructible(const AllDefaulted), "");
+  static_assert(__is_trivially_copy_constructible(const AllDefaulted), "");
+
+  static_assert(!__is_copy_constructible(volatile AllDefaulted), "");
+  static_assert(!__is_nothrow_copy_constructible(volatile AllDefaulted), "");
+  static_assert(!__is_trivially_copy_constructible(volatile AllDefaulted), "");
+
+  static_assert(!__is_copy_constructible(const volatile AllDefaulted), "");
+  static_assert(!__is_nothrow_copy_constructible(const volatile AllDefaulted), "");
+  static_assert(!__is_trivially_copy_constructible(const volatile AllDefaulted), "");
+
+  static_assert(__is_copy_constructible(CEmptyStruct), "");
+  static_assert(__is_nothrow_copy_constructible(CEmptyStruct), "");
+  static_assert(__is_trivially_copy_constructible(CEmptyStruct), "");
+
+  static_assert(__is_copy_constructible(CppEmptyStruct), "");
+  static_assert(__is_nothrow_copy_constructible(CppEmptyStruct), "");
+  static_assert(__is_trivially_copy_constructible(CppEmptyStruct), "");
+
+  static_assert(__is_copy_constructible(CppStructNonStandardBy2ndVirtBase), "");
+  static_assert(__is_nothrow_copy_constructible(CppStructNonStandardBy2ndVirtBase), "");
+  static_assert(__is_trivially_copy_constructible(CppStructNonStandardBy2ndVirtBase), "");
+
+  static_assert(__is_copy_constructible(CppStructNonStandardByBase), "");
+  static_assert(__is_nothrow_copy_constructible(CppStructNonStandardByBase), "");
+  static_assert(__is_trivially_copy_constructible(CppStructNonStandardByBase), "");
+
+  static_assert(__is_copy_constructible(CppStructNonStandardByMemb), "");
+  static_assert(__is_nothrow_copy_constructible(CppStructNonStandardByMemb), "");
+  static_assert(!__is_trivially_copy_constructible(CppStructNonStandardByMemb), "");
+
+  static_assert(__is_copy_constructible(CppStructNonStandardByProt), "");
+  static_assert(__is_nothrow_copy_constructible(CppStructNonStandardByProt), "");
+  static_assert(__is_trivially_copy_constructible(CppStructNonStandardByProt), "");
+
+  static_assert(__is_copy_constructible(CppStructNonStandardBySameBase), "");
+  static_assert(__is_nothrow_copy_constructible(CppStructNonStandardBySameBase), "");
+  static_assert(__is_trivially_copy_constructible(CppStructNonStandardBySameBase), "");
+
+  static_assert(__is_copy_constructible(CppStructNonStandardByVirt), "");
+  static_assert(__is_nothrow_copy_constructible(CppStructNonStandardByVirt), "");
+  static_assert(!__is_trivially_copy_constructible(CppStructNonStandardByVirt), "");
+
+  static_assert(__is_copy_constructible(CppStructNonStandardByVirtBase), "");
+  static_assert(__is_nothrow_copy_constructible(CppStructNonStandardByVirtBase), "");
+  static_assert(!__is_trivially_copy_constructible(CppStructNonStandardByVirtBase), "");
+
+  static_assert(__is_copy_constructible(CppStructStandard), "");
+  static_assert(__is_nothrow_copy_constructible(CppStructStandard), "");
+  static_assert(__is_trivially_copy_constructible(CppStructStandard), "");
+
+  static_assert(__is_copy_constructible(CStruct), "");
+  static_assert(__is_nothrow_copy_constructible(CStruct), "");
+  static_assert(__is_trivially_copy_constructible(CStruct), "");
+
+  static_assert(__is_copy_constructible(CVCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(CVCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(CVCopyCtor), "");
+
+  static_assert(__is_copy_constructible(const CVCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(const CVCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(const CVCopyCtor), "");
+
+  static_assert(__is_copy_constructible(volatile CVCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(volatile CVCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(volatile CVCopyCtor), "");
+
+  static_assert(__is_copy_constructible(const volatile CVCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(const volatile CVCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(const volatile CVCopyCtor), "");
+
+  static_assert(__is_copy_constructible(Derives), "");
+  static_assert(__is_nothrow_copy_constructible(Derives), "");
+  static_assert(__is_trivially_copy_constructible(Derives), "");
+
+  static_assert(__is_copy_constructible(DerivesHasRef), "");
+  static_assert(__is_nothrow_copy_constructible(DerivesHasRef), "");
+  static_assert(__is_trivially_copy_constructible(DerivesHasRef), "");
+
+  static_assert(__is_copy_constructible(Empty), "");
+  static_assert(__is_nothrow_copy_constructible(Empty), "");
+  static_assert(__is_trivially_copy_constructible(Empty), "");
+
+  static_assert(__is_copy_constructible(EmptyUnion), "");
+  static_assert(__is_nothrow_copy_constructible(EmptyUnion), "");
+  static_assert(__is_trivially_copy_constructible(EmptyUnion), "");
+
+  static_assert(__is_copy_constructible(Enum), "");
+  static_assert(__is_nothrow_copy_constructible(Enum), "");
+  static_assert(__is_trivially_copy_constructible(Enum), "");
+
+  static_assert(__is_copy_constructible(const Enum), "");
+  static_assert(__is_nothrow_copy_constructible(const Enum), "");
+  static_assert(__is_trivially_copy_constructible(const Enum), "");
+
+  static_assert(__is_copy_constructible(volatile Enum), "");
+  static_assert(__is_nothrow_copy_constructible(volatile Enum), "");
+  static_assert(__is_trivially_copy_constructible(volatile Enum), "");
+
+  static_assert(__is_copy_constructible(const volatile Enum), "");
+  static_assert(__is_nothrow_copy_constructible(const volatile Enum), "");
+  static_assert(__is_trivially_copy_constructible(const volatile Enum), "");
+
+  static_assert(__is_copy_constructible(EnumClass), "");
+  static_assert(__is_nothrow_copy_constructible(EnumClass), "");
+  static_assert(__is_trivially_copy_constructible(EnumClass), "");
+
+  static_assert(__is_copy_constructible(const EnumClass), "");
+  static_assert(__is_nothrow_copy_constructible(const EnumClass), "");
+  static_assert(__is_trivially_copy_constructible(const EnumClass), "");
+
+  static_assert(__is_copy_constructible(volatile EnumClass), "");
+  static_assert(__is_nothrow_copy_constructible(volatile EnumClass), "");
+  static_assert(__is_trivially_copy_constructible(volatile EnumClass), "");
+
+  static_assert(__is_copy_constructible(const volatile EnumClass), "");
+  static_assert(__is_nothrow_copy_constructible(const volatile EnumClass), "");
+  static_assert(__is_trivially_copy_constructible(const volatile EnumClass), "");
+
+  static_assert(__is_copy_constructible(ExtDefaulted), "");
+  static_assert(!__is_nothrow_copy_constructible(ExtDefaulted), "");
+  static_assert(!__is_trivially_copy_constructible(ExtDefaulted), "");
+
+  static_assert(__is_copy_constructible(ExtDefaulted), "");
+  static_assert(!__is_nothrow_copy_constructible(ExtDefaulted), "");
+  static_assert(!__is_trivially_copy_constructible(ExtDefaulted), "");
+
+  static_assert(__is_copy_constructible(HasCons), "");
+  static_assert(__is_nothrow_copy_constructible(HasCons), "");
+  static_assert(__is_trivially_copy_constructible(HasCons), "");
+
+  static_assert(__is_copy_constructible(HasCopyAssign), "");
+  static_assert(__is_nothrow_copy_constructible(HasCopyAssign), "");
+  static_assert(__is_trivially_copy_constructible(HasCopyAssign), "");
+
+  static_assert(__is_copy_constructible(HasDest), "");
+  static_assert(__is_nothrow_copy_constructible(HasDest), "");
+  static_assert(!__is_trivially_copy_constructible(HasDest), "");
+
+  static_assert(__is_copy_constructible(HasMultipleCopy), "");
+  static_assert(__is_nothrow_copy_constructible(HasMultipleCopy), "");
+  static_assert(!__is_trivially_copy_constructible(HasMultipleCopy), "");
+
+  static_assert(__is_copy_constructible(HasPriv), "");
+  static_assert(__is_nothrow_copy_constructible(HasPriv), "");
+  static_assert(__is_trivially_copy_constructible(HasPriv), "");
+
+  static_assert(__is_copy_constructible(HasRef), "");
+  static_assert(__is_nothrow_copy_constructible(HasRef), "");
+  static_assert(__is_trivially_copy_constructible(HasRef), "");
+
+  static_assert(__is_copy_constructible(HasTemplateCons), "");
+  static_assert(__is_nothrow_copy_constructible(HasTemplateCons), "");
+  static_assert(!__is_trivially_copy_constructible(HasTemplateCons), "");
+
+  static_assert(__is_copy_constructible(const HasTemplateCons), "");
+  static_assert(__is_nothrow_copy_constructible(const HasTemplateCons), "");
+  static_assert(!__is_trivially_copy_constructible(const HasTemplateCons), "");
+
+  static_assert(__is_copy_constructible(volatile HasTemplateCons), "");
+  static_assert(!__is_nothrow_copy_constructible(volatile HasTemplateCons), "");
+  static_assert(!__is_trivially_copy_constructible(volatile HasTemplateCons), "");
+
+  static_assert(__is_copy_constructible(const volatile HasTemplateCons), "");
+  static_assert(!__is_nothrow_copy_constructible(const volatile HasTemplateCons), "");
+  static_assert(!__is_trivially_copy_constructible(const volatile HasTemplateCons), "");
+
+  static_assert(__is_copy_constructible(NoDefaultMoveAssignDueToDtor), "");
+  static_assert(__is_nothrow_copy_constructible(NoDefaultMoveAssignDueToDtor), "");
+  static_assert(!__is_trivially_copy_constructible(NoDefaultMoveAssignDueToDtor), "");
+
+  static_assert(__is_copy_constructible(NoDefaultMoveAssignDueToUDCopyAssign), "");
+  static_assert(__is_nothrow_copy_constructible(NoDefaultMoveAssignDueToUDCopyAssign), "");
+  static_assert(__is_trivially_copy_constructible(NoDefaultMoveAssignDueToUDCopyAssign), "");
+
+  static_assert(__is_copy_constructible(NoDefaultMoveAssignDueToUDCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(NoDefaultMoveAssignDueToUDCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(NoDefaultMoveAssignDueToUDCopyCtor), "");
+
+  static_assert(__is_copy_constructible(NonTCStruct), "");
+  static_assert(!__is_nothrow_copy_constructible(NonTCStruct), "");
+  static_assert(!__is_trivially_copy_constructible(NonTCStruct), "");
+
+  static_assert(__is_copy_constructible(NonTrivialStruct), "");
+  static_assert(__is_nothrow_copy_constructible(NonTrivialStruct), "");
+  static_assert(__is_trivially_copy_constructible(NonTrivialStruct), "");
+
+  static_assert(__is_copy_constructible(SuperNonTrivialStruct), "");
+  static_assert(__is_nothrow_copy_constructible(SuperNonTrivialStruct), "");
+  static_assert(!__is_trivially_copy_constructible(SuperNonTrivialStruct), "");
+
+  static_assert(__is_copy_constructible(TrivialStruct), "");
+  static_assert(__is_nothrow_copy_constructible(TrivialStruct), "");
+  static_assert(__is_trivially_copy_constructible(TrivialStruct), "");
+
+  static_assert(__is_copy_constructible(Union), "");
+  static_assert(__is_nothrow_copy_constructible(Union), "");
+  static_assert(__is_trivially_copy_constructible(Union), "");
+
+  static_assert(__is_copy_constructible(NothrowCopyConstructible), "");
+  static_assert(__is_nothrow_copy_constructible(NothrowCopyConstructible), "");
+  static_assert(!__is_trivially_copy_constructible(NothrowCopyConstructible), "");
+
+  static_assert(!__is_copy_constructible(AllDeleted), "");
+  static_assert(!__is_nothrow_copy_constructible(AllDeleted), "");
+  static_assert(!__is_trivially_copy_constructible(AllDeleted), "");
+
+  static_assert(!__is_copy_constructible(AllPrivate), "");
+  static_assert(!__is_nothrow_copy_constructible(AllPrivate), "");
+  static_assert(!__is_trivially_copy_constructible(AllPrivate), "");
+
+  static_assert(!__is_copy_constructible(AnIncompleteType[]), "");
+  static_assert(!__is_nothrow_copy_constructible(AnIncompleteType[]), "");
+  static_assert(!__is_trivially_copy_constructible(AnIncompleteType[]), "");
+
+  static_assert(!__is_copy_constructible(AnIncompleteType), ""); // expected-error{{incomplete type}}
+  static_assert(!__is_nothrow_copy_constructible(AnIncompleteType), ""); // expected-error{{incomplete type}}
+  static_assert(!__is_trivially_copy_constructible(AnIncompleteType), ""); // expected-error{{incomplete type}}
+
+  static_assert(!__is_copy_constructible(BaseDeletedCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(BaseDeletedCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(BaseDeletedCopyCtor), "");
+
+  static_assert(!__is_copy_constructible(CopyCtorDeleted), "");
+  static_assert(!__is_nothrow_copy_constructible(CopyCtorDeleted), "");
+  static_assert(!__is_trivially_copy_constructible(CopyCtorDeleted), "");
+
+  static_assert(!__is_copy_constructible(HasMutableCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(HasMutableCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(HasMutableCopyCtor), "");
+
+  static_assert(!__is_copy_constructible(HasMove), "");
+  static_assert(!__is_nothrow_copy_constructible(HasMove), "");
+  static_assert(!__is_trivially_copy_constructible(HasMove), "");
+
+  static_assert(!__is_copy_constructible(HasMoveAssign), "");
+  static_assert(!__is_nothrow_copy_constructible(HasMoveAssign), "");
+  static_assert(!__is_trivially_copy_constructible(HasMoveAssign), "");
+
+  static_assert(!__is_copy_constructible(MemberDeletedCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(MemberDeletedCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(MemberDeletedCopyCtor), "");
+
+  static_assert(!__is_copy_constructible(VirtAr), "");
+  static_assert(!__is_nothrow_copy_constructible(VirtAr), "");
+  static_assert(!__is_trivially_copy_constructible(VirtAr), "");
+
+  static_assert(!__is_copy_constructible(VolatileCopyCtor), "");
+  static_assert(!__is_nothrow_copy_constructible(VolatileCopyCtor), "");
+  static_assert(!__is_trivially_copy_constructible(VolatileCopyCtor), "");
+
+  // Non-referencable types
+  static_assert(!__is_copy_constructible(void), "");
+  static_assert(!__is_nothrow_copy_constructible(void), "");
+  static_assert(!__is_trivially_copy_constructible(void), "");
+
+  static_assert(!__is_copy_constructible(void()), "");
+  static_assert(!__is_nothrow_copy_constructible(void()), "");
+  static_assert(!__is_trivially_copy_constructible(void()), "");
+}
+
 // 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))]; }