Rename isPODType (using the C++98 rules) into isCXX98PODType and make isPODType decide which one to use based on LangOptions.

- -Wc++98-compat depends on the c++98 definition
- Now __is_pod returns the right thing in c++11 and c++98 mode
- All changes to the type traits test are validated against g++ 4.7

llvm-svn: 155756

4 files changed, 27 insertions, 13 deletions

diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index 7b615c19dcc..50f30c232af 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -634,6 +634,11 @@ public:
   /// \brief Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
   bool isPODType(ASTContext &Context) const;
 
+  /// isCXX98PODType() - Return true if this is a POD type according to the
+  /// rules of the C++98 standard, regardless of the current compilation's
+  /// language.
+  bool isCXX98PODType(ASTContext &Context) 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.
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 3f6a09457d1..38b8e9f7582 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -895,6 +895,14 @@ bool Type::isIncompleteType(NamedDecl **Def) const {
 }
 
 bool QualType::isPODType(ASTContext &Context) const {
+  // C++11 has a more relaxed definition of POD.
+  if (Context.getLangOpts().CPlusPlus0x)
+    return isCXX11PODType(Context);
+
+  return isCXX98PODType(Context);
+}
+
+bool QualType::isCXX98PODType(ASTContext &Context) const {
   // The compiler shouldn't query this for incomplete types, but the user might.
   // We return false for that case. Except for incomplete arrays of PODs, which
   // are PODs according to the standard.
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index d2e0e6b63b4..043a6f7fde5 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -560,7 +560,8 @@ ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
   // Complain about passing non-POD types through varargs. However, don't
   // perform this check for incomplete types, which we can get here when we're
   // in an unevaluated context.
-  if (!E->getType()->isIncompleteType() && !E->getType().isPODType(Context)) {
+  if (!E->getType()->isIncompleteType() &&
+      !E->getType().isCXX98PODType(Context)) {
     // C++0x [expr.call]p7:
     //   Passing a potentially-evaluated argument of class type (Clause 9) 
     //   having a non-trivial copy constructor, a non-trivial move constructor,
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index f53939ac179..63286e6e13c 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -131,25 +131,25 @@ void is_pod()
   { int arr[T(__is_pod(HasAnonymousUnion))]; }
   { int arr[T(__is_pod(Vector))]; }
   { int arr[T(__is_pod(VectorExt))]; }
+  { int arr[T(__is_pod(Derives))]; }
+  { int arr[T(__is_pod(DerivesAr))]; }
+  { int arr[T(__is_pod(DerivesArNB))]; }
+  { int arr[T(__is_pod(DerivesEmpty))]; }
+  { int arr[T(__is_pod(HasPriv))]; }
+  { int arr[T(__is_pod(HasProt))]; }
+  { int arr[T(__is_pod(DerivesHasPriv))]; }
+  { int arr[T(__is_pod(DerivesHasProt))]; }
 
-  { int arr[F(__is_pod(Derives))]; }
-  { int arr[F(__is_pod(DerivesAr))]; }
-  { int arr[F(__is_pod(DerivesArNB))]; }
-  { int arr[F(__is_pod(DerivesEmpty))]; }
   { int arr[F(__is_pod(HasCons))]; }
   { int arr[F(__is_pod(HasCopyAssign))]; }
   { int arr[F(__is_pod(HasMoveAssign))]; }
   { int arr[F(__is_pod(HasDest))]; }
-  { int arr[F(__is_pod(HasPriv))]; }
-  { int arr[F(__is_pod(HasProt))]; }
   { int arr[F(__is_pod(HasRef))]; }
   { int arr[F(__is_pod(HasVirt))]; }
   { int arr[F(__is_pod(DerivesHasCons))]; }
   { int arr[F(__is_pod(DerivesHasCopyAssign))]; }
   { int arr[F(__is_pod(DerivesHasMoveAssign))]; }
   { int arr[F(__is_pod(DerivesHasDest))]; }
-  { int arr[F(__is_pod(DerivesHasPriv))]; }
-  { int arr[F(__is_pod(DerivesHasProt))]; }
   { int arr[F(__is_pod(DerivesHasRef))]; }
   { int arr[F(__is_pod(DerivesHasVirt))]; }
   { int arr[F(__is_pod(NonPOD))]; }
@@ -1223,10 +1223,10 @@ void has_trivial_copy_constructor() {
   { int arr[T(__has_trivial_copy(const Int))]; }
   { int arr[T(__has_trivial_copy(AllDefaulted))]; }
   { int arr[T(__has_trivial_copy(AllDeleted))]; }
+  { int arr[T(__has_trivial_copy(DerivesAr))]; }
 
   { int arr[F(__has_trivial_copy(HasCopy))]; }
   { int arr[F(__has_trivial_copy(HasTemplateCons))]; }
-  { int arr[F(__has_trivial_copy(DerivesAr))]; }
   { int arr[F(__has_trivial_copy(VirtAr))]; }
   { int arr[F(__has_trivial_copy(void))]; }
   { int arr[F(__has_trivial_copy(cvoid))]; }
@@ -1250,13 +1250,13 @@ void has_trivial_copy_assignment() {
   { int arr[T(__has_trivial_assign(HasMoveAssign))]; }
   { int arr[T(__has_trivial_assign(AllDefaulted))]; }
   { int arr[T(__has_trivial_assign(AllDeleted))]; }
+  { int arr[T(__has_trivial_assign(DerivesAr))]; }
 
   { int arr[F(__has_trivial_assign(IntRef))]; }
   { int arr[F(__has_trivial_assign(HasCopyAssign))]; }
   { int arr[F(__has_trivial_assign(const Int))]; }
   { int arr[F(__has_trivial_assign(ConstIntAr))]; }
   { int arr[F(__has_trivial_assign(ConstIntArAr))]; }
-  { int arr[F(__has_trivial_assign(DerivesAr))]; }
   { int arr[F(__has_trivial_assign(VirtAr))]; }
   { int arr[F(__has_trivial_assign(void))]; }
   { int arr[F(__has_trivial_assign(cvoid))]; }
@@ -1338,6 +1338,7 @@ void has_nothrow_assign() {
   { int arr[T(__has_nothrow_assign(HasVirtDest))]; }
   { int arr[T(__has_nothrow_assign(AllPrivate))]; }
   { int arr[T(__has_nothrow_assign(UsingAssign))]; }
+  { int arr[T(__has_nothrow_assign(DerivesAr))]; }
 
   { int arr[F(__has_nothrow_assign(IntRef))]; }
   { int arr[F(__has_nothrow_assign(HasCopyAssign))]; }
@@ -1345,7 +1346,6 @@ void has_nothrow_assign() {
   { int arr[F(__has_nothrow_assign(const Int))]; }
   { int arr[F(__has_nothrow_assign(ConstIntAr))]; }
   { int arr[F(__has_nothrow_assign(ConstIntArAr))]; }
-  { int arr[F(__has_nothrow_assign(DerivesAr))]; }
   { int arr[F(__has_nothrow_assign(VirtAr))]; }
   { int arr[F(__has_nothrow_assign(void))]; }
   { int arr[F(__has_nothrow_assign(cvoid))]; }
@@ -1375,10 +1375,10 @@ void has_nothrow_copy() {
   { int arr[T(__has_nothrow_copy(HasVirtDest))]; }
   { int arr[T(__has_nothrow_copy(HasTemplateCons))]; }
   { int arr[T(__has_nothrow_copy(AllPrivate))]; }
+  { int arr[T(__has_nothrow_copy(DerivesAr))]; }
 
   { int arr[F(__has_nothrow_copy(HasCopy))]; }
   { int arr[F(__has_nothrow_copy(HasMultipleCopy))]; }
-  { int arr[F(__has_nothrow_copy(DerivesAr))]; }
   { int arr[F(__has_nothrow_copy(VirtAr))]; }
   { int arr[F(__has_nothrow_copy(void))]; }
   { int arr[F(__has_nothrow_copy(cvoid))]; }