diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -147,7 +147,7 @@ "variable length array folded to constant array as an extension">, InGroup; 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">; diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def --- a/clang/include/clang/Basic/TokenKinds.def +++ b/clang/include/clang/Basic/TokenKinds.def @@ -466,12 +466,24 @@ 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) @@ -518,7 +530,14 @@ // 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) diff --git a/clang/lib/Lex/PPMacroExpansion.cpp b/clang/lib/Lex/PPMacroExpansion.cpp --- a/clang/lib/Lex/PPMacroExpansion.cpp +++ b/clang/lib/Lex/PPMacroExpansion.cpp @@ -1700,6 +1700,8 @@ .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); diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp --- a/clang/lib/Parse/ParseDeclCXX.cpp +++ b/clang/lib/Parse/ParseDeclCXX.cpp @@ -1578,12 +1578,17 @@ 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, @@ -1602,17 +1607,24 @@ 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, @@ -1620,6 +1632,7 @@ 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, diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp --- a/clang/lib/Parse/ParseExpr.cpp +++ b/clang/lib/Parse/ParseExpr.cpp @@ -1067,6 +1067,7 @@ 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); @@ -1102,6 +1103,7 @@ 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); @@ -1109,6 +1111,7 @@ 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); diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -21,12 +21,14 @@ #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" @@ -4756,12 +4758,16 @@ 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: @@ -4782,6 +4788,7 @@ 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. @@ -4841,6 +4848,18 @@ 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; @@ -4884,6 +4903,12 @@ return false; } +static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, + ArrayRef 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"); @@ -4901,8 +4926,20 @@ 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: @@ -4913,6 +4950,8 @@ return T->isMemberDataPointerType(); case UTT_IsEnum: return T->isEnumeralType(); + case UTT_IsScopedEnum: + return T->isScopedEnumeralType(); case UTT_IsUnion: return T->isUnionType(); case UTT_IsClass: @@ -5284,26 +5323,78 @@ 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 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 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 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: { @@ -5387,6 +5478,16 @@ 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; @@ -5416,24 +5517,32 @@ 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; @@ -5573,7 +5682,8 @@ 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: // @@ -5612,8 +5722,14 @@ 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)); @@ -5634,7 +5750,18 @@ 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: diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -2627,12 +2627,10 @@ 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. diff --git a/clang/test/SemaCXX/deprecated-builtins.cpp b/clang/test/SemaCXX/deprecated-builtins.cpp --- a/clang/test/SemaCXX/deprecated-builtins.cpp +++ b/clang/test/SemaCXX/deprecated-builtins.cpp @@ -5,15 +5,15 @@ 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}} } diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp --- a/clang/test/SemaCXX/type-traits.cpp +++ b/clang/test/SemaCXX/type-traits.cpp @@ -345,11 +345,19 @@ } 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))]; } @@ -363,6 +371,29 @@ { 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 { }; @@ -702,6 +733,106 @@ 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 void tmpl_func(T&) {} template struct type_wrapper { @@ -934,6 +1065,42 @@ 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; @@ -1481,8 +1648,8 @@ typedef const IntAr ConstIntAr; typedef ConstIntAr ConstIntArAr[4]; -struct HasCopy { - HasCopy(HasCopy& cp); +struct HasMutableCopyCtor { + HasMutableCopyCtor(HasMutableCopyCtor &cp); }; struct HasMove { @@ -1518,7 +1685,7 @@ { 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))]; } @@ -1581,7 +1748,7 @@ { 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))]; } @@ -1601,7 +1768,7 @@ { 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))]; } @@ -1635,7 +1802,7 @@ { 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))]; } @@ -1692,7 +1859,7 @@ { 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))]; } @@ -1801,7 +1968,7 @@ { 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))]; } @@ -1831,7 +1998,7 @@ { 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))]; } @@ -1858,7 +2025,7 @@ { 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))]; } @@ -2325,6 +2492,1137 @@ { 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 struct is_trivially_constructible { @@ -2401,6 +3699,92 @@ { 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; + using RRef = ConvertsToRef; + using CLRef = ConvertsToRef; + using LongRef = ConvertsToRef; + { 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; + using RRef = ConvertsToRef; + using CLRef = ConvertsToRef; + using LongRef = ConvertsToRef; + { 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)]; @@ -3295,6 +4679,8 @@ static_assert(__is_same(remove_cvref_t, M), ""); static_assert(__is_same(remove_pointer_t, M), ""); static_assert(__is_same(remove_reference_t, M), ""); + + static_assert(!__is_referenceable(M), ""); } };