Lit C++11 Compatibility Patch #9

[tigerleapgorge]

Summary

Continuing to make Lit tests C++11 compatibility.
11 tests in this patch.

CodeGenCXX/debug-info-use-after-free.cpp

Mark base class destructor “~AAA(){}” as “protected” so that the derived class
“C3” can inherit from it.
Otherwise we would get the following Error in C++11:
  C++11: error: deleted function '~C3' cannot override a non-deleted function
         note: overridden virtual function is here

CodeGenCXX/dynamic-cast-hint.cpp

Mark base class destructors protected so that they can be inherited.
Otherwise we would get the following Error in C++11:
  C++11: error: deleted function '~C' cannot override a non-deleted function
         note: overridden virtual function is here

SemaCXX/i-c-e-cxx.cpp

This test verifies GNU extensions.
Change in diagnostics.
  C++98: error: expression is not an integral constant expression
  C++11: error: case value is not a constant expression

Restrict the following to C++98:
  C++98: note: read of object outside its lifetime is not allowed 
               in a constant expression
  C++98: warning: no case matching constant switch condition '1'
  C++98: warning: in-class initializer for static data member is not a constant
                  expression; folding it to a constant is a GNU extension
  C++98: warning: 'long long' is a C++11 extension [-Wc++11-long-long]
  C++98: warning: warning: variable length array folded to constant array as an 
                  extension [-Wgnu-folding-constant]
         note: initializer of 'nonconst' is not a constant expression
         note: declared here

SemaCXX/new-delete.cpp

C++11 has one additional note following no matching constructor error.
  Existing: error: no matching constructor for initialization of 'S' 
  Existing: note: candidate constructor (the implicit copy constructor) not viable
     C++11: candidate constructor (the implicit move constructor) not viable

Change in diagnostics (2 instances)
  C++98: error: array size expression must have integral or enumeration type, not 'S'
  C++11: error: array size expression must have integral or unscoped enumeration type,
                not 'S'

Change in diagnostics
  C++98: error: expected expression
  C++11: error: expected variable name or 'this' in lambda capture list

  C++98: error: no suitable member 'operator delete' in 'X11'
         note: member 'operator delete' declared here
         note: implicit destructor for 'X11' first required here
  C++11: error: deleted function '~X11' cannot override a non-deleted function
         note: overridden virtual function is here
         error: attempt to use a deleted function
         note: virtual destructor requires an unambiguous, accessible 'operator delete'

  C++98: error: field of type 'ArrayNewNeedsDtor::A' has private destructor
         note: declared private here
         note: implicit destructor for 'ArrayNewNeedsDtor::B' first required here
  C++11: error: attempt to use a deleted function
         note: destructor of 'B' is implicitly deleted because field 'a' has an inaccessible destructor

SemaCXX/no-wchar.cpp

C++11 had deprecated wchar_t. 
Change in diagnostics.
  C++98: conversion from string literal to 'wchar_t *' 
         (aka 'unsigned short *') is deprecated
  C++11: ISO C++11 does not allow conversion from string literal to 'wchar_t *' 
         (aka 'unsigned short *')

SemaCXX/virtual-member-functions-key-function.cpp

Change in diagnostics (2 instances)
  C++98: error: no suitable member 'operator delete' in 'B'
         note: member 'operator delete' declared here
         note: implicit destructor for 'B' first required here
  C++11: error: deleted function '~B' cannot override a non-deleted function
         note: overridden virtual function is here

SemaCXX/warn-bool-conversion.cpp

C++11 is more strict with pointer initializations.
Boolean literal conversion diagnostics changed from Warning in C++98/03 to 
Error with Note in C++11.
  C++98: warning: initialization of pointer of type 'int *' to null from a 
                  constant boolean expression [-Wbool-conversion]
  C++11: error: cannot initialize a variable of type 'int *' with an 
                rvalue of type 'bool'

  C++98: warning: initialization of pointer of type 'int *' to null from a 
                  constant boolean expression [-Wbool-conversion]
  C++11: error: cannot initialize a parameter of type 'int *' with an 
                rvalue of type 'bool'
         note: passing argument to parameter 'j' here

  C++98: warning: initialization of pointer of type 'int *' to null from a 
                  constant boolean expression [-Wbool-conversion]
  C++11: error: no matching function for call to 'foo'
         note: candidate function not viable: requires 2 arguments, but 1 was provided

Calling the function “void foo(int* i, int *j=(false))” with one actual argument 
was OK in C++98/03, but is an Error in C++11.
Added the following.
  C++11: Error: no matching function for call to 'foo'.

SemaCXX/zero-length-arrays.cpp

In this test, class Bar has contains 3 zero-length arrays of class Foo. 
Class Foo has a private copy constructor.
Bar’s implicit copy constructor was considered undefined was C++98/03, 
it is considered deleted in C++11. [class.copy] 12.8 \ 11.
http://en.cppreference.com/w/cpp/language/copy_constructor#Deleted_implicitly-declared_copy_constructor

Added the followed expected diagnostics for C++11.
  C++11: error: call to implicitly-deleted copy constructor of 'Bar'
          note: copy constructor of 'Bar' is implicitly deleted because 
                field 'foos' has an inaccessible copy constructor

SemaTemplate/instantiate-c99.cpp

Added static_cast<>() inside designated initializers.
Otherwise compiling this test in C++11 would result in the following Error.
  C++11: error: non-constant-expression cannot be narrowed from type 'int' 
                to 'float' in initializer list [-Wc++11-narrowing]

SemaTemplate/temp_explicit.cpp

Restrict the following to C++98.
  C++98: warning: explicit instantiation of 'X0<char, char>' that occurs
                  after an explicit specialization will be ignored 
                  (C++11 extension) [-Wc++11-extensions]
         note: previous template specialization is here

Change in severity for the follow 3 diagnostics.
  C++98: warning: explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'
  C++11: error: explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'

  C++98: warning: explicit instantiation of 'N1::X7' must occur in namespace 'N1'
  C++11: error: explicit instantiation of 'N1::X7' must occur in namespace 'N1'

  C++98: warning: explicit instantiation of 'X9' must occur at global scope
  C++11: error: explicit instantiation of 'X9' must occur at global scope

SemaTemplate/value-dependent-null-pointer-constant.cpp

String literal and int is no longer compatible in C++11.
Added 3 expected Errors for C++11. 
  C++11: error: incompatible operand types ('const char *' and 'int')
  C++11: error: incompatible operand types ('int' and 'const char *')
  C++11: error: comparison between pointer and integer ('const char *' and 'int')

[tigerleapgorge]

Forgot to provide context last time.
Last patch was created using command: svn diff
This patch was created using command: svn diff --diff-cmd=diff -x -U999999

[tigerleapgorge]

Lit C++11 compatibility patch #9

Update patch again to expect for latest Trunk C++11 diagnostics.
Tests in CXX directory are already passing in C++11, so they are removed from this patch.
Of the remaining tests, 4 tests are modified to accommodate for changes is diagnostics.

SemaCXX/implicit-virtual-member-functions.cpp

Additional Note message in latest Trunk (3 instances).
  Note: virtual destructor requires an unambiguous, accessible 'operator delete'

SemaCXX/new-delete.cpp

Warning no longer exist in latest Trunk
  Warning: function previously declared with an explicit exception specification redeclared with an implicit exception specification

Previous severity change (C++98 Warning  to C++11 Error) has been fixed in latest Trunk.
Revert following 2 message back to Error.
  Error: array size is negative
  Error: array is too large (2000000000 elements)

Additional Note message (1 instance).
  Note: virtual destructor requires an unambiguous, accessible 'operator delete'

SemaCXX/virtual-member-functions-key-function.cpp

Additional Note message (2 instances)
  Note: virtual destructor requires an unambiguous, accessible 'operator delete'

SemaTemplate/virtual-member-functions.cpp

Additional Note message (3 instances)
  Note: destructor of 'Inner' is implicitly deleted because base class 'PR7114::A' has an inaccessible destructor
  Note: destructor of 'Inner' is implicitly deleted because base class 'PR7114::A' has an inaccessible destructor
  Note: destructor of 'X<int>' is implicitly deleted because base class 'PR7114::A' has an inaccessible destructor

[tigerleapgorge]

Forgot to include all context inside the previous revision.

Previous patch: svn diff
This patch: svn diff --diff-cmd=diff -x -U999999

[tigerleapgorge]

Update again, remove 4 OpenMP tests here because they have been checked in rL294025 under review D29480.
13 tests left.

[tigerleapgorge]

2 tests have been reviewed in D29520
They are: implicit-virtual-member-functions.cpp and virtual-member-functions.cpp
Remove these from this patch.

[rsmith]

LGTM

cfe/trunk/test/CodeGenCXX/debug-info-use-after-free.cpp

 // RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only %s
+// RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only -std=c++98 %s
+// RUN: %clang_cc1 -debug-info-kind=limited -triple %itanium_abi_triple -emit-llvm-only -std=c++11 %s
 // Check that we don't crash.
 // PR12305, PR12315
 
 # 1 "a.h"  3
 template < typename T1 > struct Types1
 {
   typedef T1 Head;
 };

 __gnu_cxx::hash_map;
 class
 C2;
 template < class > class scoped_ptr {
 };
 namespace {
 class
     AAA {
+protected:
       virtual ~
           AAA () {
           }};
 }
 template < typename > class EEE;
 template < typename CCC, typename =
 typename CCC::key_equal, typename =
 EEE < CCC > >class III {

cfe/trunk/test/CodeGenCXX/dynamic-cast-hint.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -std=c++98 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin12 -emit-llvm -std=c++11 -o - %s | FileCheck %s
 
-class A { virtual ~A() {} };
-class B { virtual ~B() {} };
+class A { protected: virtual ~A() {} };
+class B { protected: virtual ~B() {} };
 
 class C : A { char x; };
 class D : public A { short y; };
 class E : public A, public B { int z; };
 class F : public virtual A { long long w; };
 class G : virtual A { long long w; };
 
 class H : public E { int a; };

cfe/trunk/test/SemaCXX/i-c-e-cxx.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=gnu++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=gnu++11 %s
 
 // C++-specific tests for integral constant expressions.
 
 const int c = 10;
 int ar[c];
 
 struct X0 {
   static const int value = static_cast<int>(4.0);
 };
 
 void f() {
   if (const int value = 17) {
     int array[value];
   }
 }
 
 int a() {
-  const int t=t; // expected-note {{declared here}} expected-note {{read of object outside its lifetime}}
-  switch(1) { // expected-warning {{no case matching constant switch condition '1'}}
-    case t:; // expected-error {{not an integral constant expression}} expected-note {{initializer of 't' is not a constant expression}}
+  const int t=t; // expected-note {{declared here}}
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{read of object outside its lifetime}}
+#endif
+
+  switch(1) {
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{no case matching constant switch condition '1'}}
+#endif
+    case t:; // expected-note {{initializer of 't' is not a constant expression}}
+#if __cplusplus <= 199711L
+    // expected-error@-2 {{not an integral constant expression}}
+#else
+    // expected-error@-4 {{case value is not a constant expression}}
+#endif
   }
 }
 
 // PR6206:  out-of-line definitions are legit
 namespace pr6206 {
   class Foo {
   public:
     static const int kBar;
void pr6373(const unsigned x = 0) {
   unsigned max = 80 / x;
 }
 
 
 // rdar://9204520
 namespace rdar9204520 {
   
 struct A {
-  static const int B = int(0.75 * 1000 * 1000); // expected-warning {{not a constant expression; folding it to a constant is a GNU extension}}
+  static const int B = int(0.75 * 1000 * 1000);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{not a constant expression; folding it to a constant is a GNU extension}}
+#endif
 };
 
 int foo() { return A::B; }
 }
 
 // PR11040
 const int x = 10;
 int* y = reinterpret_cast<const char&>(x); // expected-error {{cannot initialize}}
 
 // This isn't an integral constant expression, but make sure it folds anyway.
-struct PR8836 { char _; long long a; }; // expected-warning {{long long}}
-int PR8836test[(__typeof(sizeof(int)))&reinterpret_cast<const volatile char&>((((PR8836*)0)->a))]; // expected-warning {{folded to constant array as an extension}} expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
+struct PR8836 { char _; long long a; };
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{'long long' is a C++11 extension}}
+#endif
+
+int PR8836test[(__typeof(sizeof(int)))&reinterpret_cast<const volatile char&>((((PR8836*)0)->a))];
+// expected-warning@-1 {{folded to constant array as an extension}}
+// expected-note@-2 {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
+
+const int nonconst = 1.0;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{declared here}}
+#endif
+int arr[nonconst];
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{folded to constant array as an extension}}
+// expected-note@-3 {{initializer of 'nonconst' is not a constant expression}}
+#endif
 
-const int nonconst = 1.0; // expected-note {{declared here}}
-int arr[nonconst]; // expected-warning {{folded to constant array as an extension}} expected-note {{initializer of 'nonconst' is not a constant expression}}
 const int castfloat = static_cast<int>(1.0);
 int arr2[castfloat]; // ok

cfe/trunk/test/SemaCXX/new-delete.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu -Wno-new-returns-null
+// RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu -Wno-new-returns-null -std=c++98
+// RUN: %clang_cc1 -fsyntax-only -verify %s -triple=i686-pc-linux-gnu -Wno-new-returns-null -std=c++11
 
 #include <stddef.h>
 
+#if __cplusplus >= 201103L
+// expected-note@+2 {{candidate constructor (the implicit move constructor) not viable}}
+#endif
 struct S // expected-note {{candidate}}
 {
   S(int, int, double); // expected-note {{candidate}}
   S(double, int); // expected-note 2 {{candidate}}
   S(float, int); // expected-note 2 {{candidate}}
 };
 struct T; // expected-note{{forward declaration of 'T'}}
 struct U

 };
 
 void bad_news(int *ip)
 {
   int i = 1; // expected-note 2{{here}}
   (void)new; // expected-error {{expected a type}}
   (void)new 4; // expected-error {{expected a type}}
   (void)new () int; // expected-error {{expected expression}}
-  (void)new int[1.1]; // expected-error {{array size expression must have integral or enumeration type, not 'double'}}
+  (void)new int[1.1];
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{array size expression must have integral or enumeration type, not 'double'}}
+#else
+  // expected-error@-4 {{array size expression must have integral or unscoped enumeration type, not 'double'}}
+#endif
+
   (void)new int[1][i]; // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
   (void)new (int[1][i]); // expected-error {{only the first dimension}} expected-note {{read of non-const variable 'i' is not allowed in a constant expression}}
   (void)new (int[i]); // expected-warning {{when type is in parentheses}}
   (void)new int(*(S*)0); // expected-error {{no viable conversion from 'S' to 'int'}}
   (void)new int(1, 2); // expected-error {{excess elements in scalar initializer}}
   (void)new S(1); // expected-error {{no matching constructor}}
   (void)new S(1, 1); // expected-error {{call to constructor of 'S' is ambiguous}}
   (void)new const int; // expected-error {{default initialization of an object of const type 'const int'}}
   (void)new float*(ip); // expected-error {{cannot initialize a new value of type 'float *' with an lvalue of type 'int *'}}
   // Undefined, but clang should reject it directly.
   (void)new int[-1]; // expected-error {{array size is negative}}
   (void)new int[2000000000]; // expected-error {{array is too large}}
-  (void)new int[*(S*)0]; // expected-error {{array size expression must have integral or enumeration type, not 'S'}}
+  (void)new int[*(S*)0];
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{array size expression must have integral or enumeration type, not 'S'}}
+#else
+  // expected-error@-4 {{array size expression must have integral or unscoped enumeration type, not 'S'}}
+#endif
+
   (void)::S::new int; // expected-error {{expected unqualified-id}}
   (void)new (0, 0) int; // expected-error {{no matching function for call to 'operator new'}}
   (void)new (0L) int; // expected-error {{call to 'operator new' is ambiguous}}
   // This must fail, because the member version shouldn't be found.
   (void)::new ((S*)0) U; // expected-error {{no matching function for call to 'operator new'}}
   // This must fail, because any member version hides all global versions.
   (void)new U; // expected-error {{no matching function for call to 'operator new'}}
   (void)new (int[]); // expected-error {{array size must be specified in new expressions}}
   (void)new int&; // expected-error {{cannot allocate reference type 'int &' with new}}
   // Some lacking cases due to lack of sema support.
 }
 
 void good_deletes()
 {
   delete (int*)0;
   delete [](int*)0;
   delete (S*)0;
   ::delete (int*)0;
 }
 
 void bad_deletes()
 {
   delete 0; // expected-error {{cannot delete expression of type 'int'}}
-  delete [0] (int*)0; // expected-error {{expected expression}}
+  delete [0] (int*)0;
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{expected expression}}
+#else
+  // expected-error@-4 {{expected variable name or 'this' in lambda capture list}}
+#endif
   delete (void*)0; // expected-warning {{cannot delete expression with pointer-to-'void' type 'void *'}}
   delete (T*)0; // expected-warning {{deleting pointer to incomplete type}}
   ::S::delete (int*)0; // expected-error {{expected unqualified-id}}
 }
 
 struct X0 { };
 
 struct X1 {

 };
 
 void f(X9 *x9) {
   delete x9; // expected-error {{no suitable member 'operator delete' in 'X9'}}
 }
 
 struct X10 {
   virtual ~X10();
-};
-
-struct X11 : X10 { // expected-error {{no suitable member 'operator delete' in 'X11'}}
-  void operator delete(void*, int); // expected-note {{'operator delete' declared here}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{overridden virtual function is here}}
+#endif
+};
+
+struct X11 : X10 {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'X11'}}
+#else
+// expected-error@-4 {{deleted function '~X11' cannot override a non-deleted function}}
+// expected-note@-5 2 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+#endif
+  void operator delete(void*, int);
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{'operator delete' declared here}}
+#endif
 };
 
 void f() {
-  X11 x11; // expected-note {{implicit destructor for 'X11' first required here}}
+  X11 x11;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{implicit destructor for 'X11' first required here}}
+#else
+  // expected-error@-4 {{attempt to use a deleted function}}
+#endif
 }
 
 struct X12 {
   void* operator new(size_t, void*);
 };
 
 struct X13 : X12 {
   using X12::operator new;

 
 namespace PR7702 {
   void test1() {
     new DoesNotExist; // expected-error {{unknown type name 'DoesNotExist'}}
   }
 }
 
 namespace ArrayNewNeedsDtor {
-  struct A { A(); private: ~A(); }; // expected-note {{declared private here}}
-  struct B { B(); A a; }; // expected-error {{field of type 'ArrayNewNeedsDtor::A' has private destructor}}
+  struct A { A(); private: ~A(); };
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{declared private here}}
+#endif
+  struct B { B(); A a; };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{field of type 'ArrayNewNeedsDtor::A' has private destructor}}
+#else
+  // expected-note@-4 {{destructor of 'B' is implicitly deleted because field 'a' has an inaccessible destructor}}
+#endif
+
   B *test9() {
-    return new B[5]; // expected-note {{implicit destructor for 'ArrayNewNeedsDtor::B' first required here}}
+    return new B[5];
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit destructor for 'ArrayNewNeedsDtor::B' first required here}}
+#else
+    // expected-error@-4 {{attempt to use a deleted function}}
+#endif
   }
 }
 
 namespace DeleteIncompleteClass {
   struct A; // expected-note {{forward declaration}}
   extern A x;
   void f() { delete x; } // expected-error {{deleting incomplete class type}}
 }

cfe/trunk/test/SemaCXX/no-wchar.cpp

 // RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify %s
+// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify -std=c++98 %s
+// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only -fno-wchar -verify -std=c++11 %s
 wchar_t x; // expected-error {{unknown type name 'wchar_t'}}
 
 typedef unsigned short wchar_t;
 void foo(const wchar_t* x);
 
 void bar() {
   foo(L"wide string literal");
 }
 
 void foo1(wchar_t * t = L"");
-// expected-warning@-1 {{conversion from string literal to 'wchar_t *' (aka 'unsigned short *') is deprecated}}
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{conversion from string literal to 'wchar_t *' (aka 'unsigned short *') is deprecated}}
+#else
+// expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'wchar_t *' (aka 'unsigned short *')}}
+#endif
 
 short *a = L"";
 // expected-error@-1 {{cannot initialize a variable of type 'short *' with an lvalue of type 'const unsigned short [1]'}}
 char *b = L"";
 // expected-error@-1 {{cannot initialize a variable of type 'char *' with an lvalue of type 'const unsigned short [1]'}}
 
 // NOTE: MSVC allows deprecated conversion in conditional expression if at least
 // one of the operand is a string literal but Clang doesn't allow it.

cfe/trunk/test/SemaCXX/virtual-member-functions-key-function.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
 struct A {
   virtual ~A();
+#if __cplusplus >= 201103L
+// expected-note@-2 2 {{overridden virtual function is here}}
+#endif
 };
 
-struct B : A {  // expected-error {{no suitable member 'operator delete' in 'B'}}
-  B() { } // expected-note {{implicit destructor for 'B' first required here}}
-  void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
+struct B : A {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'B'}}
+#else
+// expected-error@-4 {{deleted function '~B' cannot override a non-deleted function}}
+// expected-note@-5  {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+#endif
+  B() { }
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'B' first required here}}
+#endif
+
+  void operator delete(void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 }; 
 
-struct C : A {  // expected-error {{no suitable member 'operator delete' in 'C'}}
-  void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
+struct C : A {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'C'}}
+#else
+// expected-error@-4 {{deleted function '~C' cannot override a non-deleted function}}
+// expected-note@-5  {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+#endif
+  void operator delete(void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 }; 
 
 void f() {
   (void)new B; 
-  (void)new C; // expected-note {{implicit destructor for 'C' first required here}}
+  (void)new C;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'C' first required here}}
+#endif
 }
 
 // Make sure that the key-function computation is consistent when the
 // first virtual member function of a nested class has an inline body.
 struct Outer {
   struct Inner {
     virtual void f() { }
     void g();
   };
 };
 
 void Outer::Inner::g() { }

cfe/trunk/test/SemaCXX/warn-bool-conversion.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 namespace BooleanFalse {
-int* j = false; // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
-
-void foo(int* i, int *j=(false)) // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+int* j = false;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{cannot initialize a variable of type 'int *' with an rvalue of type 'bool'}}
+#endif
+
+#if __cplusplus <= 199711L
+// expected-warning@+6 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@+4 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'bool'}}
+// expected-note@+3 {{passing argument to parameter 'j' here}}
+// expected-note@+2 6 {{candidate function not viable: requires 2 arguments, but 1 was provided}}
+#endif
+void foo(int* i, int *j=(false))
 {
-  foo(false); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
-  foo((int*)false); // no-warning: explicit cast
-  foo(0); // no-warning: not a bool, even though its convertible to bool
-
-  foo(false == true); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
-  foo((42 + 24) < 32); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+  foo(false);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
+
+  foo((int*)false);
+#if __cplusplus <= 199711L
+// no-warning: explicit cast
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
+
+  foo(0);
+#if __cplusplus <= 199711L
+// no-warning: not a bool, even though its convertible to bool
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
+
+  foo(false == true);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
+
+  foo((42 + 24) < 32);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
 
   const bool kFlag = false;
-  foo(kFlag); // expected-warning{{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+  foo(kFlag);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{initialization of pointer of type 'int *' to null from a constant boolean expression}}
+#else
+// expected-error@-4 {{no matching function for call to 'foo'}}
+#endif
 }
 
 char f(struct Undefined*);
 double f(...);
 
 // Ensure that when using false in metaprogramming machinery its conversion
 // isn't flagged.
 template <int N> struct S {};

cfe/trunk/test/SemaCXX/zero-length-arrays.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
-// expected-no-diagnostics
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // <rdar://problem/10228639>
 class Foo {
   ~Foo();
   Foo(const Foo&);
 public:
   Foo(int);
 };
 
 class Bar {
   int foo_count;
   Foo foos[0];
+#if __cplusplus >= 201103L
+// expected-note@-2 {{copy constructor of 'Bar' is implicitly deleted because field 'foos' has an inaccessible copy constructor}}
+#endif
   Foo foos2[0][2];
   Foo foos3[2][0];
 
 public:
   Bar(): foo_count(0) { }    
   ~Bar() { }
 };
 
 void testBar() {
   Bar b;
   Bar b2(b);
+#if __cplusplus >= 201103L
+// expected-error@-2 {{call to implicitly-deleted copy constructor of 'Bar}}
+#else
+// expected-no-diagnostics
+#endif
   b = b2;
 }

cfe/trunk/test/SemaTemplate/instantiate-c99.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // Test template instantiation for C99-specific features.
 
 // ---------------------------------------------------------------------
 // Designated initializers
 // ---------------------------------------------------------------------
 template<typename T, typename XType, typename YType>
 struct DesigInit0 {
   void f(XType x, YType y) {
     T agg = { 
+#if __cplusplus <= 199711L
       .y = y, // expected-error{{does not refer}}
       .x = x  // expected-error{{does not refer}}
+#else
+      .y = static_cast<float>(y), // expected-error{{does not refer}}
+      .x = static_cast<float>(x)  // expected-error{{does not refer}}
+#endif
     };
   }
 };
 
 struct Point2D {
   float x, y;
 };
 

 template struct DesigInit0<ColorPoint3D, int, double>;
 template struct DesigInit0<Color, int, double>; // expected-note{{instantiation}}
 
 template<typename T, int Subscript1, int Subscript2,
          typename Val1, typename Val2>
 struct DesigArrayInit0 {
   void f(Val1 val1, Val2 val2) {
     T array = {
+#if __cplusplus <= 199711L
       [Subscript1] = val1,
+#else
+      [Subscript1] = static_cast<int>(val1),
+#endif
       [Subscript2] = val2 // expected-error{{exceeds array bounds}}
     };
 
     int array2[10] = { [5] = 3 };
   }
 };
 
 template struct DesigArrayInit0<int[8], 5, 3, float, int>;
 template struct DesigArrayInit0<int[8], 5, 13, float, int>; // expected-note{{instantiation}}
 
 template<typename T, int Subscript1, int Subscript2,
          typename Val1>
 struct DesigArrayRangeInit0 {
   void f(Val1 val1) {
     T array = {
+#if __cplusplus <= 199711L
       [Subscript1...Subscript2] = val1 // expected-error{{exceeds}}
+#else
+      [Subscript1...Subscript2] = static_cast<int>(val1) // expected-error{{exceeds}}
+#endif
     };
   }
 };
 
 template struct DesigArrayRangeInit0<int[8], 3, 5, float>;
 template struct DesigArrayRangeInit0<int[8], 5, 13, float>; // expected-note{{instantiation}}
 
 // ---------------------------------------------------------------------
 // Compound literals
 // ---------------------------------------------------------------------
 template<typename T, typename Arg1, typename Arg2>
 struct CompoundLiteral0 {
   T f(Arg1 a1, Arg2 a2) {
+#if __cplusplus <= 199711L
     return (T){a1, a2};
+#else
+    return (T){static_cast<float>(a1), a2};
+#endif
   }
 };
 
 template struct CompoundLiteral0<Point2D, int, float>;

cfe/trunk/test/SemaTemplate/temp_explicit.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
 //
 // Tests explicit instantiation of templates.
 template<typename T, typename U = T> class X0 { };
 
 namespace N {
   template<typename T, typename U = T> class X1 { };
 }
 

 
 using namespace N2;
 template struct X5<int&>::Inner2; // expected-note{{instantiation}}
 
 void f4(X5<float&>::Inner2);
 template struct X5<float&>::Inner2; // expected-note{{instantiation}}
 
 namespace N3 {
-  template struct N2::X5<int>::Inner2; // expected-warning {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
+  template struct N2::X5<int>::Inner2;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
+#else
+// expected-error@-4 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
+#endif
 }
 
 struct X6 {
   struct Inner { // expected-note{{here}}
     void f();
   };
 };
 

 
 template<typename T> struct X9 { }; // expected-note{{here}}
 
 template struct ::N1::Inner::X8<float>;
 
 namespace N2 {
   using namespace N1;
 
-  template struct X7<double>; // expected-warning{{must occur in namespace}}
-
-  template struct X9<float>; // expected-warning{{must occur at global scope}}
+  template struct X7<double>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
+#else
+// expected-error@-4 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
+#endif
+
+  template struct X9<float>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'X9' must occur at global scope}}
+#else
+// expected-error@-4 {{explicit instantiation of 'X9' must occur at global scope}}
+#endif
 }

cfe/trunk/test/SemaTemplate/value-dependent-null-pointer-constant.cpp

-// RUN: %clang_cc1 -fsyntax-only %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 template<typename T, int N>
 struct X0 {
   const char *f0(bool Cond) {
     return Cond? "honk" : N;
+#if __cplusplus >= 201103L
+// expected-error@-2 {{incompatible operand types ('const char *' and 'int')}}
+#else
+// expected-no-diagnostics
+#endif
   }
 
   const char *f1(bool Cond) {
     return Cond? N : "honk";
+#if __cplusplus >= 201103L
+// expected-error@-2 {{incompatible operand types ('int' and 'const char *')}}
+#endif
   }
   
   bool f2(const char *str) {
     return str == N;
+#if __cplusplus >= 201103L
+// expected-error@-2 {{comparison between pointer and integer ('const char *' and 'int')}}
+#endif
   }
 };
 
 // PR4996
 template<unsigned I> int f0() { 
   return __builtin_choose_expr(I, 0, 1); 
 }
 
 // PR5041
 struct A { };
 
 template <typename T> void f(T *t)
 {
   (void)static_cast<void*>(static_cast<A*>(t));
 }