[ObjC] Make C++ triviality type traits available to non-trivial C

structs.

r326307 and r327870 made changes that allowed using non-trivial C
structs with fields qualified with __strong or __weak. This commit makes
the following C++ triviality type traits available to non-trivial C
structs:

__has_trivial_assign
__has_trivial_move_assign
__has_trivial_copy
__has_trivial_move_constructor
__has_trivial_constructor
__has_trivial_destructor

This reapplies r328680. This commit fixes a bug where the copy/move
__has_trivial_* traits would return false when a volatile type was being
passed. Thanks to Richard Smith for pointing out the mistake.

rdar://problem/33599681

Differential Revision: https://reviews.llvm.org/D44913

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@329289 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def
index f18e06f5b7de2010d70523b60038ea105e89c3bb..56f3a6929a93b58655c5536c703ce136cd88548c 100644 (file)
--- a/include/clang/Basic/TokenKinds.def
+++ b/include/clang/Basic/TokenKinds.def
@@ -433,12 +433,12 @@ TYPE_TRAIT_1(__has_nothrow_assign, HasNothrowAssign, KEYCXX)
 TYPE_TRAIT_1(__has_nothrow_move_assign, HasNothrowMoveAssign, KEYCXX)
 TYPE_TRAIT_1(__has_nothrow_copy, HasNothrowCopy, KEYCXX)
 TYPE_TRAIT_1(__has_nothrow_constructor, HasNothrowConstructor, KEYCXX)
-TYPE_TRAIT_1(__has_trivial_assign, HasTrivialAssign, KEYCXX)
-TYPE_TRAIT_1(__has_trivial_move_assign, HasTrivialMoveAssign, KEYCXX)
-TYPE_TRAIT_1(__has_trivial_copy, HasTrivialCopy, KEYCXX)
-TYPE_TRAIT_1(__has_trivial_constructor, HasTrivialDefaultConstructor, KEYCXX)
-TYPE_TRAIT_1(__has_trivial_move_constructor, HasTrivialMoveConstructor, KEYCXX)
-TYPE_TRAIT_1(__has_trivial_destructor, HasTrivialDestructor, KEYCXX)
+TYPE_TRAIT_1(__has_trivial_assign, HasTrivialAssign, KEYALL)
+TYPE_TRAIT_1(__has_trivial_move_assign, HasTrivialMoveAssign, KEYALL)
+TYPE_TRAIT_1(__has_trivial_copy, HasTrivialCopy, KEYALL)
+TYPE_TRAIT_1(__has_trivial_constructor, HasTrivialDefaultConstructor, KEYALL)
+TYPE_TRAIT_1(__has_trivial_move_constructor, HasTrivialMoveConstructor, KEYALL)
+TYPE_TRAIT_1(__has_trivial_destructor, HasTrivialDestructor, KEYALL)
 TYPE_TRAIT_1(__has_virtual_destructor, HasVirtualDestructor, KEYCXX)
 TYPE_TRAIT_1(__is_abstract, IsAbstract, KEYCXX)
 TYPE_TRAIT_1(__is_aggregate, IsAggregate, KEYCXX)

diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index 56b95c45aa0ba9e7c60fce755e9be587621b4a30..f72147924f3b7e247d97a0483e5c304919565f1f 100644 (file)
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -4521,6 +4521,8 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
     // does not correctly compute triviality in the presence of multiple special
     // members of the same kind. Revisit this once the g++ bug is fixed.
   case UTT_HasTrivialDefaultConstructor:
+    if (T.isNonTrivialToPrimitiveDefaultInitialize())
+      return false;
     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
     //   If __is_pod (type) is true then the trait is true, else if type is
     //   a cv class or union type (or array thereof) with a trivial default
@@ -4531,7 +4533,11 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
       return RD->hasTrivialDefaultConstructor() &&
              !RD->hasNonTrivialDefaultConstructor();
     return false;
-  case UTT_HasTrivialMoveConstructor:
+  case UTT_HasTrivialMoveConstructor: {
+    QualType::PrimitiveCopyKind PCK =
+        T.isNonTrivialToPrimitiveDestructiveMove();
+    if (PCK != QualType::PCK_Trivial && PCK != QualType::PCK_VolatileTrivial)
+      return false;
     //  This trait is implemented by MSVC 2012 and needed to parse the
     //  standard library headers. Specifically this is used as the logic
     //  behind std::is_trivially_move_constructible (20.9.4.3).
@@ -4540,7 +4546,11 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
     if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
       return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor();
     return false;
-  case UTT_HasTrivialCopy:
+  }
+  case UTT_HasTrivialCopy: {
+    QualType::PrimitiveCopyKind PCK = T.isNonTrivialToPrimitiveCopy();
+    if (PCK != QualType::PCK_Trivial && PCK != QualType::PCK_VolatileTrivial)
+      return false;
     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
     //   If __is_pod (type) is true or type is a reference type then
     //   the trait is true, else if type is a cv class or union type
@@ -4552,7 +4562,12 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
       return RD->hasTrivialCopyConstructor() &&
              !RD->hasNonTrivialCopyConstructor();
     return false;
-  case UTT_HasTrivialMoveAssign:
+  }
+  case UTT_HasTrivialMoveAssign: {
+    QualType::PrimitiveCopyKind PCK =
+        T.isNonTrivialToPrimitiveDestructiveMove();
+    if (PCK != QualType::PCK_Trivial && PCK != QualType::PCK_VolatileTrivial)
+      return false;
     //  This trait is implemented by MSVC 2012 and needed to parse the
     //  standard library headers. Specifically it is used as the logic
     //  behind std::is_trivially_move_assignable (20.9.4.3)
@@ -4561,7 +4576,11 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
     if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl())
       return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment();
     return false;
-  case UTT_HasTrivialAssign:
+  }
+  case UTT_HasTrivialAssign: {
+    QualType::PrimitiveCopyKind PCK = T.isNonTrivialToPrimitiveCopy();
+    if (PCK != QualType::PCK_Trivial && PCK != QualType::PCK_VolatileTrivial)
+      return false;
     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
     //   If type is const qualified or is a reference type then the
     //   trait is false. Otherwise if __is_pod (type) is true then the
@@ -4582,6 +4601,7 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
       return RD->hasTrivialCopyAssignment() &&
              !RD->hasNonTrivialCopyAssignment();
     return false;
+  }
   case UTT_IsDestructible:
   case UTT_IsTriviallyDestructible:
   case UTT_IsNothrowDestructible:
@@ -4632,6 +4652,8 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
     return true;
 
   case UTT_HasTrivialDestructor:
+    if (T.isDestructedType() == QualType::DK_nontrivial_c_struct)
+      return false;
     // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html
     //   If __is_pod (type) is true or type is a reference type
     //   then the trait is true, else if type is a cv class or union

diff --git a/test/SemaObjC/non-trivial-struct-traits.m b/test/SemaObjC/non-trivial-struct-traits.m
new file mode 100644 (file)
index 0000000..b907bdc
--- /dev/null
+++ b/test/SemaObjC/non-trivial-struct-traits.m
@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -verify %s
+
+// expected-no-diagnostics
+
+struct Trivial {
+  int x;
+};
+
+struct NonTrivial {
+  id x;
+};
+
+int trivial_assign[__has_trivial_assign(struct Trivial) ? 1 : -1];
+int trivial_move_assign[__has_trivial_move_assign(struct Trivial) ? 1 : -1];
+int trivial_copy_constructor[__has_trivial_copy(struct Trivial) ? 1 : -1];
+int trivial_move_constructor[__has_trivial_move_constructor(struct Trivial) ? 1 : -1];
+int trivial_constructor[__has_trivial_constructor(struct Trivial) ? 1 : -1];
+int trivial_destructor[__has_trivial_destructor(struct Trivial) ? 1 : -1];
+
+int non_trivial_assign[__has_trivial_assign(struct NonTrivial) ? -1 : 1];
+int non_trivial_move_assign[__has_trivial_move_assign(struct NonTrivial) ? -1 : 1];
+int non_trivial_copy_constructor[__has_trivial_copy(struct NonTrivial) ? -1 : 1];
+int non_trivial_move_constructor[__has_trivial_move_constructor(struct NonTrivial) ? -1 : 1];
+int non_trivial_constructor[__has_trivial_constructor(struct NonTrivial) ? -1 : 1];
+int non_trivial_destructor[__has_trivial_destructor(struct NonTrivial) ? -1 : 1];
+
+int volatile_trivial_assign[__has_trivial_assign(volatile int) ? 1 : -1];
+int volatile_trivial_move_assign[__has_trivial_move_assign(volatile int) ? 1 : -1];
+int volatile_trivial_copy_constructor[__has_trivial_copy(volatile int) ? 1 : -1];
+int volatile_trivial_move_constructor[__has_trivial_move_constructor(volatile int) ? 1 : -1];
+int volatile_trivial_copy_constructor2[__has_trivial_copy(volatile struct Trivial) ? 1 : -1];
+int volatile_trivial_move_constructor2[__has_trivial_move_constructor(volatile struct Trivial) ? 1 : -1];