Hoist all of the type-specific trait logic for __is_standard_layout into

a Type method isStandardLayoutType, to keep our user API matching the
type trait builtins as closely as possible. Also, implement it in terms
of other Type APIs rather than in terms of other type traits. This
models the implementation on that of isLiteralType and isTrivialType.
There remain some common problems with these traits still, so this is
a bit of a WIP. However, we can now fix all of these traits at the same
time and in a consistent manner.

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

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index c2d492b3bbd620152069edac89088aec7291f1a2..c1b8a775a6866da6c4d1573f40fc57e972b4cc27 100644 (file)
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -1179,6 +1179,10 @@ public:
   /// (C++0x [basic.types]p9)
   bool isTrivialType() const;
 
+  /// \brief Test if this type is a standard-layout type.
+  /// (C++0x [basic.type]p9)
+  bool isStandardLayoutType() const;
+
   /// isCXX11PODType() - Return true if this is a POD type according to the
   /// more relaxed rules of the C++11 standard, regardless of the current
   /// compilation's language.
@@ -2842,9 +2846,6 @@ public:
   // const, it needs to return false.
   bool hasConstFields() const { return false; }
 
-  /// \brief Whether this class has standard layout
-  bool hasStandardLayout() const;
-
   bool isSugared() const { return false; }
   QualType desugar() const { return QualType(this, 0); }
 

diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 55f01e5822c1e1414cde8d6fd4d17620d7aa469b..dbced252aa296366e9b2db523a8aa8a365ff12f0 100644 (file)
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -943,9 +943,36 @@ bool Type::isTrivialType() const {
   return false;
 }
 
-// This is effectively the intersection of isTrivialType and hasStandardLayout.
-// We implement it dircetly to avoid redundant conversions from a type to
-// a CXXRecordDecl.
+bool Type::isStandardLayoutType() const {
+  if (isIncompleteType())
+    return false;
+
+  // C++0x [basic.types]p9:
+  //   Scalar types, standard-layout class types, arrays of such types, and
+  //   cv-qualified versions of these types are collectively called
+  //   standard-layout types.
+  const Type *BaseTy = getBaseElementTypeUnsafe();
+  assert(BaseTy && "NULL element type");
+  if (BaseTy->isScalarType()) return true;
+  if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
+    if (const CXXRecordDecl *ClassDecl =
+        dyn_cast<CXXRecordDecl>(RT->getDecl()))
+      if (!ClassDecl->hasStandardLayout())
+        return false;
+
+    // Default to 'true' for non-C++ class types.
+    // FIXME: This is a bit dubious, but plain C structs should trivially meet
+    // all the requirements of standard layout classes.
+    return true;
+  }
+
+  // No other types can match.
+  return false;
+}
+
+// This is effectively the intersection of isTrivialType and
+// isStandardLayoutType. We implement it dircetly to avoid redundant
+// conversions from a type to a CXXRecordDecl.
 bool Type::isCXX11PODType() const {
   if (isIncompleteType())
     return false;
@@ -1448,17 +1475,6 @@ static uint64_t countBasesWithFields(QualType BaseType) {
   return BasesWithFields;
 }
 
-bool RecordType::hasStandardLayout() const {
-  CXXRecordDecl *RD = cast<CXXRecordDecl>(getDecl());
-  if (! RD) {
-    assert(cast<RecordDecl>(getDecl()) &&
-           "RecordType does not have a corresponding RecordDecl");
-    return true;
-  }
-
-  return RD->hasStandardLayout();
-}
-
 bool EnumType::classof(const TagType *TT) {
   return isa<EnumDecl>(TT->getDecl());
 }

diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index d975a155cd7730dd573b422dfc3d5794f253aebf..d87752081b3bbbb3295238b46e673e715abf7bfd 100644 (file)
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -2438,22 +2438,7 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, UnaryTypeTrait UTT, QualType T,
   case UTT_IsSigned:
     return T->isSignedIntegerType();
   case UTT_IsStandardLayout:
-    // Error if T is an incomplete type.
-    if (Self.RequireCompleteType(KeyLoc, T, diag::err_incomplete_typeid))
-      return false;
-
-    // A standard layout type is:
-    // - a scalar type
-    // - an array of standard layout types
-    // - a standard layout class type:
-    if (EvaluateUnaryTypeTrait(Self, UTT_IsScalar, T, KeyLoc))
-      return true;
-    if (EvaluateUnaryTypeTrait(Self, UTT_IsScalar, C.getBaseElementType(T),
-                               KeyLoc))
-      return true;
-    if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>())
-      return RT->hasStandardLayout();
-    return false;
+    return T->isStandardLayoutType();
   case UTT_IsUnsigned:
     return T->isUnsignedIntegerType();
   case UTT_IsVoid: