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

test/CXX/basic/basic.stc/basic.stc.dynamic/p2-noexceptions.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
+
 namespace std {
   class bad_alloc { };
   
   typedef __SIZE_TYPE__ size_t;
 }
 
 class foo { virtual ~foo(); };
 
 void* operator new(std::size_t); 
 void* operator new[](std::size_t);
 void operator delete(void*);
+#if __cplusplus >= 201103L
+// expected-warning@-2 {{function previously declared with an explicit exception specification redeclared with an implicit exception specificatio}}
+#else
+// expected-no-diagnostics
+#endif
 void operator delete[](void*);
+#if __cplusplus >= 201103L
+// expected-warning@-2 {{function previously declared with an explicit exception specification redeclared with an implicit exception specificatio}}
+#endif

test/CXX/basic/basic.stc/basic.stc.dynamic/p2.cpp

 // RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -fexceptions -fcxx-exceptions -verify -std=c++11 %s
+
 int *use_new(int N) {
   if (N == 1)
     return new int;
   
   return new int [N];
 }
 
 void use_delete(int* ip, int N) {
   if (N == 1)
     delete ip;
   else
     delete [] ip;
 }
 
 namespace std {
   class bad_alloc { };
   
   typedef __SIZE_TYPE__ size_t;
 }
 
-void* operator new(std::size_t) throw(std::bad_alloc); // expected-note{{previous declaration}}
+void* operator new(std::size_t) throw(std::bad_alloc);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous declaration is here}}
+#endif
+
 void* operator new[](std::size_t) throw(std::bad_alloc); 
 void operator delete(void*) throw(); // expected-note{{previous declaration}}
 void operator delete[](void*) throw();
 
-void* operator new(std::size_t); // expected-warning{{'operator new' is missing exception specification 'throw(std::bad_alloc)'}}
-void operator delete(void*); // expected-warning{{'operator delete' is missing exception specification 'throw()'}}
+void* operator new(std::size_t);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{'operator new' is missing exception specification 'throw(std::bad_alloc)'}}
+#endif
+
+void operator delete(void*);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{'operator delete' is missing exception specification 'throw()'}}
+#else
+// expected-warning@-4 {{function previously declared with an explicit exception specification redeclared with an implicit exception specification}}
+#endif

test/CXX/class.access/class.friend/p1.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
 
 // C++'0x [class.friend] p1:
 //   A friend of a class is a function or class that is given permission to use
 //   the private and protected member names from the class. A class specifies
 //   its friends, if any, by way of friend declarations. Such declarations give
 //   special access rights to the friends, but they do not make the nominated
 //   friends members of the befriending class.
 
class B {
       int test(A *p) { return p->x; }
     };
   }
 }
 
 // PR6207
 namespace test6 {
   struct A {};
+#if __cplusplus >= 201103L
+    // expected-note@-2 {{previous declaration is here}}
+#endif
 
   struct B {
     friend A::A();
+#if __cplusplus >= 201103L
+    // expected-error@-2 {{non-constexpr declaration of 'A' follows constexpr declaration}}
+#endif
     friend A::~A();
     friend A &A::operator=(const A&);
   };
 }
 
 namespace test7 {
   template <class T> struct X {
     X();
+    X(const X&);
     ~X();
     void foo();
     void bar();
   };
 
   class A {
     friend void X<int>::foo();
     friend X<int>::X();

test/CXX/class.access/p4.cpp

 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
 
 // C++0x [class.access]p4:
 
 //   Access control is applied uniformly to all names, whether the
 //   names are referred to from declarations or expressions.  In the
 //   case of overloaded function names, access control is applied to
 //   the function selected by overload resolution.
 
void test(A &a, Public &pub, Protected &prot, Private &priv) {
     ca(priv); // expected-error {{'operator void (*)(Private &)' is a private member}}
   }
 }
 
 // Implicit constructor calls.
 namespace test2 {
   class A {
   private:
-    A(); // expected-note 3 {{declared private here}}
-
+    A();
+#if __cplusplus <= 199711L
+    // expected-note@-2 3 {{declared private here}}
+#else
+    // expected-note@-4 {{declared private here}}
+#endif
     static A foo;
   };
 
   A a; // expected-error {{calling a private constructor}}
   A A::foo; // okay
   
-  class B : A { }; // expected-error {{base class 'test2::A' has private default constructor}}
-  B b; // expected-note{{implicit default constructor}}
-  
+  class B : A { };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{base class 'test2::A' has private default constructor}}
+#else
+  // expected-note@-4 {{default constructor of 'B' is implicitly deleted because base class 'test2::A' has an inaccessible default constructor}}
+#endif
+  B b;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{implicit default constructor}}
+#else
+  // expected-error@-4 {{call to implicitly-deleted default constructor of 'test2::B'}}
+#endif
   class C : virtual A { 
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{default constructor of 'D' is implicitly deleted because base class 'test2::A' has an inaccessible default constructor}}
+#endif
   public:
     C();
   };
 
-  class D : C { }; // expected-error {{inherited virtual base class 'test2::A' has private default constructor}}
-  D d; // expected-note{{implicit default constructor}}
+  class D : C { };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{inherited virtual base class 'test2::A' has private default constructor}}
+#endif
+  D d;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{implicit default constructor}}
+#else
+  // expected-error@-4 {{call to implicitly-deleted default constructor of 'test2::D'}}
+#endif
 }
 
 // Implicit destructor calls.
 namespace test3 {
   class A {
   private:
     ~A(); // expected-note 2 {{declared private here}}
     static A foo;
   };
 
   A a; // expected-error {{variable of type 'test3::A' has private destructor}}
   A A::foo;
 
   void foo(A param) { // okay
     A local; // expected-error {{variable of type 'test3::A' has private destructor}}
   }
 
-  template <unsigned N> class Base { ~Base(); }; // expected-note 14 {{declared private here}}
-  class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 3 {{declared private here}} \
-                                               // expected-error {{base class 'Base<2>' has private destructor}}
-  class Base3 : virtual Base<3> { public: ~Base3(); }; // expected-error {{base class 'Base<3>' has private destructor}}
-
+  template <unsigned N> class Base { ~Base(); };
+#if __cplusplus <= 199711L
+  // expected-note@-2 14 {{declared private here}}
+#else
+  // expected-note@-4 4 {{declared private here}}
+#endif
+  class Base2 : virtual Base<2> { ~Base2(); };
+#if __cplusplus <= 199711L
+  // expected-note@-2 3 {{declared private here}}
+  // expected-error@-3 {{base class 'Base<2>' has private destructor}}
+#else
+  // expected-note@-5 {{declared private here}}
+#endif
+  class Base3 : virtual Base<3> { public: ~Base3(); };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{base class 'Base<3>' has private destructor}}
+#endif
   // These don't cause diagnostics because we don't need the destructor.
   class Derived0 : Base<0> { ~Derived0(); };
   class Derived1 : Base<1> { };
 
   class Derived2 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \
                    // expected-error {{inherited virtual base class 'Base<3>' has private destructor}}
     Base<0>,  // expected-error {{base class 'Base<0>' has private destructor}}
     virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}
     Base2, // expected-error {{base class 'test3::Base2' has private destructor}}
     virtual Base3
   {
     ~Derived2() {}
   };
 
-  class Derived3 : // expected-error 2 {{inherited virtual base class 'Base<2>' has private destructor}} \
-                   // expected-error 2 {{inherited virtual base class 'Base<3>' has private destructor}} \
-    // expected-note 2{{implicit default constructor}}
-    Base<0>,  // expected-error 2 {{base class 'Base<0>' has private destructor}}
-    virtual Base<1>, // expected-error 2 {{base class 'Base<1>' has private destructor}}
-    Base2, // expected-error 2 {{base class 'test3::Base2' has private destructor}}
+  class Derived3 :
+#if __cplusplus <= 199711L
+  // expected-error@-2 2 {{inherited virtual base class 'Base<2>' has private destructor}}
+  // expected-error@-3 2 {{inherited virtual base class 'Base<3>' has private destructor}}
+  // expected-note@-4 2{{implicit default constructor}}
+#endif
+    Base<0>,
+#if __cplusplus <= 199711L
+    // expected-error@-2 2 {{base class 'Base<0>' has private destructor}}
+#else
+    // expected-note@-4 {{default constructor of 'Derived3' is implicitly deleted because base class 'Base<0>' has an inaccessible destructor}}
+#endif
+    virtual Base<1>,
+#if __cplusplus <= 199711L
+    // expected-error@-2 2 {{base class 'Base<1>' has private destructor}}
+#endif
+    Base2,
+#if __cplusplus <= 199711L
+    // expected-error@-2 2 {{base class 'test3::Base2' has private destructor}}
+#endif
     virtual Base3
   {}; 
-  Derived3 d3; // expected-note {{implicit default constructor}}\
-               // expected-note{{implicit destructor}}}
+  Derived3 d3;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{implicit default constructor}}
+  // expected-note@-3 {{implicit destructor}}}
+#else
+  // expected-error@-5 {{call to implicitly-deleted default constructor of 'test3::Derived3'}}
+#endif
 }
 
 // Conversion functions.
 namespace test4 {
   class Base {
   private:
     operator Private(); // expected-note 4 {{declared private here}}
   public:
namespace test4 {
   };
   Private test1(Derived4 &d) { return d; }
   Public test2(Derived4 &d) { return d; }
 }
 
 // Implicit copy assignment operator uses.
 namespace test5 {
   class A {
-    void operator=(const A &); // expected-note 2 {{implicitly declared private here}}
+    void operator=(const A &);
+#if __cplusplus <= 199711L
+    // expected-note@-2 2 {{implicitly declared private here}}
+#endif
   };
 
-  class Test1 { A a; }; // expected-error {{private member}}
+  class Test1 { A a; };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{private member}}
+#else
+  // expected-note@-4 {{copy assignment operator of 'Test1' is implicitly deleted because field 'a' has an inaccessible copy assignment operator}}
+#endif
   void test1() {
     Test1 a; 
-    a = Test1(); // expected-note{{implicit copy}}
+    a = Test1();
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit copy}}
+#else
+    // expected-error@-4 {{object of type 'test5::Test1' cannot be assigned because its copy assignment operator is implicitly deleted}}
+#endif
   }
 
-  class Test2 : A {}; // expected-error {{private member}}
+  class Test2 : A {};
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{private member}}
+#else
+  // expected-note@-4 {{copy assignment operator of 'Test2' is implicitly deleted because base class 'test5::A' has an inaccessible copy assignment operator}}
+#endif
   void test2() {
     Test2 a;
-    a = Test2(); // expected-note{{implicit copy}}
+    a = Test2();
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit copy}}
+#else
+    // expected-error@-4 {{object of type 'test5::Test2' cannot be assigned because its copy assignment operator is implicitly deleted}}
+#endif
   }
 }
 
 // Implicit copy constructor uses.
 namespace test6 {
   class A {
     public: A();
-    private: A(const A &); // expected-note 2 {{declared private here}}
+    private: A(const A &);
+#if __cplusplus <= 199711L
+    // expected-note@-2 2 {{declared private here}}
+#endif
   };
 
-  class Test1 { A a; }; // expected-error {{field of type 'test6::A' has private copy constructor}}
+  class Test1 { A a; };
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{field of type 'test6::A' has private copy constructor}}
+#else
+  // expected-note@-4 {{copy constructor of 'Test1' is implicitly deleted because field 'a' has an inaccessible copy constructor}}
+#endif
   void test1(const Test1 &t) {
-    Test1 a = t; // expected-note{{implicit copy}}
+    Test1 a = t;
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit copy constructor for 'test6::Test1' first required here}}
+#else
+    // expected-error@-4 {{call to implicitly-deleted copy constructor of 'test6::Test1'}}
+#endif
   }
 
-  class Test2 : A {}; // expected-error {{base class 'test6::A' has private copy constructor}}
+  class Test2 : A {};
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{base class 'test6::A' has private copy constructor}}
+#else
+  // expected-note@-4 {{copy constructor of 'Test2' is implicitly deleted because base class 'test6::A' has an inaccessible copy constructor}}
+#endif
   void test2(const Test2 &t) {
-    Test2 a = t; // expected-note{{implicit copy}}
+    Test2 a = t;
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit copy constructor for 'test6::Test2' first required here}}
+#else
+    // expected-error@-4 {{call to implicitly-deleted copy constructor of 'test6::Test2'}}
+#endif
   }
 }
 
 // Redeclaration lookups are not accesses.
 namespace test7 {
   class A {
     int private_member;
   };

test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p4.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
 
 // C++03 [namespace.udecl]p4:
 //   A using-declaration used as a member-declaration shall refer to a
 //   member of a base class of the class being defined, shall refer to
 //   a member of an anonymous union that is a member of a base class
 //   of the class being defined, or shall refer to an enumerator for
 //   an enumeration type that is a member of a base class of the class
 //   being defined.
namespace test4 {
   }
 
   // We should be able to diagnose these without instantiation.
   template <class T> struct C : Base {
     using InnerNS::foo; // expected-error {{not a class}}
     using Base::bar; // expected-error {{no member named 'bar'}}
     using Unrelated::foo; // expected-error {{not a base class}}
     using C::foo; // legal in C++03
+#if __cplusplus >= 201103L
+    // expected-error@-2 {{using declaration refers to its own class}}
+#endif
+
     using Subclass::foo; // legal in C++03
+#if __cplusplus >= 201103L
+    // expected-error@-2 {{using declaration refers into 'Subclass::', which is not a base class of 'C'}}
+#endif
 
-    int bar(); //expected-note {{target of using declaration}}
+    int bar();
+#if __cplusplus <= 199711L
+    //expected-note@-2 {{target of using declaration}}
+#endif
     using C::bar; // expected-error {{refers to its own class}}
   };
 }

test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x-fixits.cpp

-// RUN: %clang_cc1 -fsyntax-only -Wc++11-compat -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -Wc++11-compat -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
 
 // Verify that the appropriate fixits are emitted for narrowing conversions in
 // initializer lists.
 
 typedef short int16_t;
 
 void fixits() {
   int x = 999;

test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5-cxx03-extra-copy.cpp

-// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -Wbind-to-temporary-copy -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -Wbind-to-temporary-copy -verify -std=c++98 %s
 
 // C++03 requires that we check for a copy constructor when binding a
 // reference to a temporary, since we are allowed to make a copy, Even
 // though we don't actually make that copy, make sure that we diagnose
 // cases where that copy constructor is somehow unavailable.  As an
 // extension, this is only a warning.
 
 struct X1 {

test/CXX/dcl.decl/dcl.init/p5.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
 
 //   A program that calls for default-initialization or value-initialization of
 //   an entity of reference type is illformed. If T is a cv-qualified type, the
 //   cv-unqualified version of T is used for these definitions of
 //   zero-initialization, default-initialization, and value-initialization.
 
-struct S { // expected-error {{implicit default constructor for 'S' must explicitly initialize the reference member}}
-  int &x; // expected-note {{declared here}} expected-error 3{{reference to type 'int' requires an initializer}}
+struct S {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{implicit default constructor for 'S' must explicitly initialize the reference member}}
+#endif
+  int &x;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{declared here}}
+// expected-error@-3 3{{reference to type 'int' requires an initializer}}
+#else
+// expected-note@-5 4 {{default constructor of 'S' is implicitly deleted because field 'x' of reference type 'int &' would not be initialized}}
+#endif
 };
-S s; // expected-note {{implicit default constructor for 'S' first required here}}
+S s;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit default constructor for 'S' first required here}}
+#else
+// expected-error@-4 {{call to implicitly-deleted default constructor of 'S'}}
+#endif
+
 S f() {
-  return S(); // expected-note {{in value-initialization of type 'S' here}}
+  return S();
+#if __cplusplus <= 199711L
+// expected-note@-2 {{in value-initialization of type 'S' here}}
+#else
+// expected-error@-4 {{call to implicitly-deleted default constructor of 'S'}}
+#endif
 }
 
 struct T
-  : S { // expected-note 2{{in value-initialization of type 'S' here}}
+  : S {
+#if __cplusplus <= 199711L
+// expected-note@-2 2 {{in value-initialization of type 'S' here}}
+#else
+// expected-note@-4 2 {{default constructor of 'T' is implicitly deleted because base class 'S' has a deleted default constructor}}
+#endif
 };
-T t = T(); // expected-note {{in value-initialization of type 'T' here}}
+T t = T();
+#if __cplusplus <= 199711L
+// expected-note@-2 {{in value-initialization of type 'T' here}}
+#else
+// expected-error@-4 {{call to implicitly-deleted default constructor of 'T'}}
+#endif
+
 
 struct U {
-  T t[3]; // expected-note {{in value-initialization of type 'T' here}}
+  T t[3];
+#if __cplusplus <= 199711L
+// expected-note@-2 {{in value-initialization of type 'T' here}}
+#else
+// expected-note@-4 {{default constructor of 'U' is implicitly deleted because field 't' has a deleted default constructor}}
+#endif
 };
-U u = U(); // expected-note {{in value-initialization of type 'U' here}}
+U u = U();
+#if __cplusplus <= 199711L
+// expected-note@-2 {{in value-initialization of type 'U' here}}
+#else
+// expected-error@-4 {{call to implicitly-deleted default constructor of 'U'}}
+#endif
+
 
 // Ensure that we handle C++11 in-class initializers properly as an extension.
 // In this case, there is no user-declared default constructor, so we
 // recursively apply the value-initialization checks, but we will emit a
 // constructor call anyway, because the default constructor is not trivial.
 struct V {
   int n;
-  int &r = n; // expected-warning {{C++11}}
+  int &r = n;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
 };
 V v = V(); // ok
 struct W {
   int n;
-  S s = { n }; // expected-warning {{C++11}}
+  S s = { n };
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
 };
 W w = W(); // ok
 
 // Ensure we're not faking this up by making the default constructor
 // non-trivial.
 #define static_assert(B, S) typedef int assert_failed[(B) ? 1 : -1];
 static_assert(__has_trivial_constructor(S), "");
 static_assert(__has_trivial_constructor(T), "");
 static_assert(__has_trivial_constructor(U), "");
 static_assert(!__has_trivial_constructor(V), "");
 static_assert(!__has_trivial_constructor(W), "");

test/CXX/special/class.dtor/p9.cpp

 // RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=gnu++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=gnu++11 %s
 // RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=gnu++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=gnu++11 %s
 
 typedef typeof(sizeof(int)) size_t;
 
 // PR7803
 namespace test0 {
   class A {
   public:
     static void operator delete(void *p) {};
namespace test2 {
 
   struct B {
     virtual ~B();
     static void operator delete(void*, const int &); // expected-note {{declared here}}
   };
   B::~B() {} // expected-error {{no suitable member 'operator delete' in 'B'}}
 
   struct CBase { virtual ~CBase(); };
-  struct C : CBase { // expected-error {{no suitable member 'operator delete' in 'C'}}
-    static void operator delete(void*, const int &); // expected-note {{declared here}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{overridden virtual function is here}}
+#endif
+
+  struct C : CBase {
+#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
+    static void operator delete(void*, const int &);
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{member 'operator delete' declared her}}
+#endif
   };
   void test() {
-    C c; // expected-note {{first required here}}
+    C c;
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{implicit destructor for 'test2::C' first required here}}
+#else
+    // expected-error@-4 {{attempt to use a deleted function}}
+#endif
   }
 }
 
 // PR7346
 namespace test3 {
   struct A {
 #ifdef MSABI
     // expected-error@+2 {{no suitable member 'operator delete' in 'A'}}

test/CXX/temp/temp.arg/temp.arg.nontype/p5.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
 
 // C++0x [temp.arg.nontype] p5:
 //   The following conversions are performed on each expression used as
 //   a non-type template-argument. If a non-type template-argument cannot be
 //   converted to the type of the corresponding template-parameter then the
 //   program is ill-formed.
 //     -- for a non-type template-parameter of integral or enumeration type,
 //        integral promotions (4.5) and integral conversions (4.7) are applied.
public:
     X();
     X(int, int);
     operator int() const;
   };
   
   template<X const *Ptr> struct A2; // expected-note{{template parameter is declared here}}
   
   X *X_ptr;
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
+
   X an_X;
   X array_of_Xs[10];
-  A2<X_ptr> *a12; // expected-error{{must have its address taken}}
+  A2<X_ptr> *a12;
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{non-type template argument for template parameter of pointer type 'const pointer_to_object_parameters::X *' must have its address taken}}
+#else
+  // expected-error@-4 {{non-type template argument of type 'pointer_to_object_parameters::X *' is not a constant expression}}
+  // expected-note@-5 {{read of non-constexpr variable 'X_ptr' is not allowed in a constant expression}}
+#endif
+
   A2<array_of_Xs> *a13;
   A2<&an_X> *a13_2;
-  A2<(&an_X)> *a13_3; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
+  A2<(&an_X)> *a13_3;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{address non-type template argument cannot be surrounded by parentheses}}
+#endif
 
   // PR6244
   struct X1 {} X1v;
   template <X1*> struct X2 { };
   template <X1* Value> struct X3 : X2<Value> { };
   struct X4 : X3<&X1v> { };
 
   // PR6563
   int *bar;
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
+
   template <int *> struct zed {}; // expected-note 2{{template parameter is declared here}}
-  void g(zed<bar>*); // expected-error{{must have its address taken}}
+  void g(zed<bar>*);
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
+#else
+  // expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
+  // expected-note@-5 {{read of non-constexpr variable 'bar' is not allowed in a constant expression}}
+#endif
 
   int baz;
-  void g2(zed<baz>*); // expected-error{{must have its address taken}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
+
+  void g2(zed<baz>*);
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
+#else
+  // expected-error@-4 {{non-type template argument of type 'int' is not a constant expression}}
+  // expected-note@-5 {{read of non-const variable 'baz' is not allowed in a constant expression}}
+#endif
 
   void g3(zed<&baz>*); // okay
 }
 
 //     -- For a non-type template-parameter of type reference to object, no
 //        conversions apply. The type referred to by the reference may be more
 //        cv-qualified than the (otherwise identical) type of the
 //        template-argument. The template-parameter is bound directly to the

 //        a set of overloaded functions (or a pointer to such), the matching
 //        function is selected from the set (13.4).
 namespace pointer_to_function {
   template<int (*)(int)> struct X0 { }; // expected-note 3{{template parameter is declared here}}
   int f(int);
   int f(float);
   int g(float);
   int (*funcptr)(int);
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
   void x0a(X0<f>);
   void x0b(X0<&f>);
   void x0c(X0<g>); // expected-error{{non-type template argument of type 'int (float)' cannot be converted to a value of type 'int (*)(int)'}}
   void x0d(X0<&g>); // expected-error{{non-type template argument of type 'int (*)(float)' cannot be converted to a value of type 'int (*)(int)'}}
-  void x0e(X0<funcptr>); // expected-error{{must have its address taken}}
+  void x0e(X0<funcptr>);
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{non-type template argument for template parameter of pointer type 'int (*)(int)' must have its address taken}}
+#else
+  // expected-error@-4 {{non-type template argument of type 'int (*)(int)' is not a constant expression}}
+  // expected-note@-5 {{read of non-constexpr variable 'funcptr' is not allowed in a constant expression}}
+#endif
 }
 
 //     -- For a non-type template-parameter of type reference to function, no
 //        conversions apply. If the template-argument represents a set of
 //        overloaded functions, the matching function is selected from the set
 //        (13.4).
 namespace reference_to_function {
   template<int (&)(int)> struct X0 { }; // expected-note 4{{template parameter is declared here}}

test/CXX/temp/temp.spec/temp.expl.spec/p4.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 IntHolder { // expected-note{{here}} // expected-note 2{{candidate constructor (the implicit copy constructor)}}
+struct IntHolder { // expected-note 2{{candidate constructor (the implicit copy constructor) not viable}}
+#if __cplusplus <=199711L
+// expected-note@-2 {{'IntHolder' declared here}}
+#else
+// expected-note@-4 2 {{candidate constructor (the implicit move constructor) not viable}}
+#endif
   IntHolder(int); // expected-note 2{{candidate constructor}}
 };
 
 template<typename T, typename U>
 struct X { // expected-note{{here}}
   void f() { 
     T t; // expected-error{{no matching}}
   }
 
   void g() { }
   
-  struct Inner {  // expected-error{{implicit default}}
-    T value;   // expected-note {{member is declared here}}
+  struct Inner {
+#if __cplusplus <=199711L
+  // expected-error@-2 {{implicit default constructor for 'X<IntHolder, int>::Inner' must explicitly initialize the member 'value' which does not have a default constructor}}
+#endif
+    T value;
+#if __cplusplus <=199711L
+    // expected-note@-2 {{member is declared here}}
+#else
+    // expected-note@-4 {{default constructor of 'Inner' is implicitly deleted because field 'value' has no default constructor}}
+#endif
   };
   
   static T value;
 };
 
 template<typename T, typename U>
 T X<T, U>::value; // expected-error{{no matching constructor}}
 
 IntHolder &test_X_IntHolderInt(X<IntHolder, int> xih) {
   xih.g(); // okay
   xih.f(); // expected-note{{instantiation}}
   
-  X<IntHolder, int>::Inner inner; // expected-note {{first required here}}
-  
+  X<IntHolder, int>::Inner inner;
+#if __cplusplus <=199711L
+  // expected-note@-2 {{implicit default constructor for 'X<IntHolder, int>::Inner' first required here}}
+#else
+  // expected-error@-4 {{call to implicitly-deleted default constructor of 'X<IntHolder, int>::Inner'}}
+#endif
   return X<IntHolder, int>::value; // expected-note{{instantiation}}
 }
 
 // Explicitly specialize the members of X<IntHolder, long> to not cause
 // problems with instantiation.
 template<>
 void X<IntHolder, long>::f() { }
 

test/CXX/temp/temp.spec/temp.explicit/p4.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
 
 template<typename T> void f0(T); // expected-note{{here}}
 template void f0(int); // expected-error{{explicit instantiation of undefined function template}}
 
 template<typename T>
 struct X0 {
   struct Inner;
   
   void f1(); // expected-note{{here}}
   
   static T value; // expected-note{{here}}
 };
 
 template void X0<int>::f1(); // expected-error{{explicit instantiation of undefined member function}}
 
 template int X0<int>::value; // expected-error{{explicit instantiation of undefined static data member}}
 
-template<> void f0(long); // expected-note{{previous template specialization is here}}
-template void f0(long); // expected-warning{{explicit instantiation of 'f0<long>' that occurs after an explicit specialization will be ignored}}
-
-template<> void X0<long>::f1(); // expected-note{{previous template specialization is here}}
-template void X0<long>::f1(); // expected-warning{{explicit instantiation of 'f1' that occurs after an explicit specialization will be ignored}}
-
-template<> struct X0<long>::Inner; // expected-note{{previous template specialization is here}}
-template struct X0<long>::Inner; // expected-warning{{explicit instantiation of 'Inner' that occurs after an explicit specialization will be ignored}}
-
-template<> long X0<long>::value; // expected-note{{previous template specialization is here}}
-template long X0<long>::value; // expected-warning{{explicit instantiation of 'value' that occurs after an explicit specialization will be ignored}}
-
-template<> struct X0<double>; // expected-note{{previous template specialization is here}}
-template struct X0<double>; // expected-warning{{explicit instantiation of 'X0<double>' that occurs after an explicit specialization will be ignored}}
+template<> void f0(long);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template void f0(long);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'f0<long>' that occurs after an explicit specialization will be ignored}}
+#endif
+
+template<> void X0<long>::f1();
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template void X0<long>::f1();
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'f1' that occurs after an explicit specialization will be ignored}}
+#endif
+
+template<> struct X0<long>::Inner;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template struct X0<long>::Inner;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'Inner' that occurs after an explicit specialization will be ignored}}
+#endif
+
+template<> long X0<long>::value;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template long X0<long>::value;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'value' that occurs after an explicit specialization will be ignored}}
+#endif
+
+template<> struct X0<double>;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+template struct X0<double>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'X0<double>' that occurs after an explicit specialization will be ignored}}
+#endif
 
 // PR 6458
 namespace test0 {
   template <class T> class foo {
     int compare(T x, T y);
   };
 
   template <> int foo<char>::compare(char x, char y);
   template <class T> int foo<T>::compare(T x, T y) {
     // invalid at T=char; if we get a diagnostic here, we're
     // inappropriately instantiating this template.
     void *ptr = x;
   }
-  extern template class foo<char>; // expected-warning {{extern templates are a C++11 extension}}
+  extern template class foo<char>;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{extern templates are a C++11 extension}}
+#endif
   template class foo<char>;
 }

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 {

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; };

test/OpenMP/distribute_collapse_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s
 
 void foo() {
 }
 
+#if __cplusplus >= 201103L
+  // expected-note@+2 4 {{declared here}}
+#endif
 bool foobool(int argc) {
   return argc;
 }
 
 struct S1; // expected-note {{declared here}}
 
 template <class T, typename S, int N, int ST> // expected-note {{declared here}}
 T tmain(T argc, S **argv) { //expected-note 2 {{declared here}}
T tmain(T argc, S **argv) { //expected-note 2 {{declared here}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   // expected-error@+1 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
   #pragma omp distribute collapse (ST // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse (1)) // expected-warning {{extra tokens at the end of '#pragma omp distribute' are ignored}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp distribute', but found only 1}}
+#if __cplusplus >= 201103L
+  // expected-note@+5 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   // expected-error@+3 2 {{directive '#pragma omp distribute' cannot contain more than one 'collapse' clause}}
   // expected-error@+2 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
   // expected-error@+1 2 {{expression is not an integral constant expression}}
   #pragma omp distribute collapse (foobool(argc)), collapse (true), collapse (-5)
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse (S) // expected-error {{'S' does not refer to a value}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
-  // expected-error@+1 2 {{expression is not an integral constant expression}}
+#if __cplusplus <= 199711L
+  // expected-error@+4 2 {{expression is not an integral constant expression}}
+#else
+  // expected-error@+2 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#endif
   #pragma omp distribute collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse (1)
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse (N) // expected-error {{argument to 'collapse' clause must be a strictly positive integer value}}
   for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp distribute collapse (2) // expected-note {{as specified in 'collapse' clause}}
   foo(); // expected-error {{expected 2 for loops after '#pragma omp distribute'}}
   return argc;
 }
 
 int main(int argc, char **argv) {
   #pragma omp distribute collapse // expected-error {{expected '(' after 'collapse'}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp distribute collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp distribute collapse () // expected-error {{expected expression}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp distribute collapse (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'collapse' clause}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp distribute', but found only 1}}
   #pragma omp distribute collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp distribute' are ignored}}  expected-note {{as specified in 'collapse' clause}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp distribute', but found only 1}}
+#if __cplusplus >= 201103L
+  // expected-note@+2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   #pragma omp distribute collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
+#if __cplusplus >= 201103L
+  // expected-note@+5 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   // expected-error@+3 {{expression is not an integral constant expression}}
   // expected-error@+2 2 {{directive '#pragma omp distribute' cannot contain more than one 'collapse' clause}}
   // expected-error@+1 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
   #pragma omp distribute collapse (foobool(argc)), collapse (true), collapse (-5) 
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp distribute collapse (S1) // expected-error {{'S1' does not refer to a value}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
-  // expected-error@+1 {{expression is not an integral constant expression}}
+#if __cplusplus <= 199711L
+  // expected-error@+4 {{expression is not an integral constant expression}}
+#else
+  // expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#endif
   #pragma omp distribute collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   // expected-error@+3 {{statement after '#pragma omp distribute' must be a for loop}}
   // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}}
   #pragma omp distribute collapse(collapse(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}}
   foo();
   #pragma omp distribute collapse (2) // expected-note {{as specified in 'collapse' clause}}
   foo(); // expected-error {{expected 2 for loops after '#pragma omp distribute'}}
   // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}}
   return tmain<int, char, 1, 0>(argc, argv);
 }
 

test/OpenMP/ordered_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -o - %s
+// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++98 -o - %s
+// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++11 -o - %s
 
 int foo();
 
 template <class T>
 T foo() {
  T k;
   #pragma omp for ordered
   for (int i = 0; i < 10; ++i) {

 #pragma omp ordered depend(source) threads // expected-error {{'depend' clauses cannot be mixed with 'threads' clause}}
 #pragma omp ordered simd depend(source) // expected-error {{'depend' clauses cannot be mixed with 'simd' clause}}
 #pragma omp ordered depend(source) depend(source) // expected-error {{directive '#pragma omp ordered' cannot contain more than one 'depend' clause with 'source' dependence}}
 #pragma omp ordered depend(in : i) // expected-error {{expected 'source' or 'sink' in OpenMP clause 'depend'}} expected-error {{'ordered' directive without any clauses cannot be closely nested inside ordered region with specified parameter}}
 #pragma omp ordered depend(sink : i, j)
 #pragma omp ordered depend(sink : j, i) // expected-error {{expected 'i' loop iteration variable}} expected-error {{expected 'j' loop iteration variable}}
 #pragma omp ordered depend(sink : i, j, k) // expected-error {{unexpected expression: number of expressions is larger than the number of associated loops}}
 #pragma omp ordered depend(sink : i+foo(), j/4) // expected-error {{expression is not an integral constant expression}} expected-error {{expected '+' or '-' operation}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{non-constexpr function 'foo' cannot be used in a constant expression}}
+#endif
 #pragma omp ordered depend(sink : i*0, j-4)// expected-error {{expected '+' or '-' operation}}
 #pragma omp ordered depend(sink : i-0, j+sizeof(T)) depend(sink : i-0, j+sizeof(T))
 #pragma omp ordered depend(sink : i-0, j+sizeof(T)) depend(source) // expected-error {{'depend(source)' clause cannot be mixed with 'depend(sink:vec)' clauses}}
 #pragma omp ordered depend(source) depend(sink : i-0, j+sizeof(T)) // expected-error {{'depend(sink:vec)' clauses cannot be mixed with 'depend(source)' clause}}
     }
   }
   return T();
 }
 
 int foo() {
+#if __cplusplus >= 201103L
+// expected-note@-2 2 {{declared here}}
+#endif
 int k;
   #pragma omp for ordered
   for (int i = 0; i < 10; ++i) {
     L1:
       foo();
     #pragma omp ordered
     {
       foo();

 #pragma omp ordered depend(source) threads // expected-error {{'depend' clauses cannot be mixed with 'threads' clause}}
 #pragma omp ordered simd depend(source) // expected-error {{'depend' clauses cannot be mixed with 'simd' clause}}
 #pragma omp ordered depend(source) depend(source) // expected-error {{directive '#pragma omp ordered' cannot contain more than one 'depend' clause with 'source' dependence}}
 #pragma omp ordered depend(in : i) // expected-error {{expected 'source' or 'sink' in OpenMP clause 'depend'}} expected-error {{'ordered' directive without any clauses cannot be closely nested inside ordered region with specified parameter}}
 #pragma omp ordered depend(sink : i, j)
 #pragma omp ordered depend(sink : j, i) // expected-error {{expected 'i' loop iteration variable}} expected-error {{expected 'j' loop iteration variable}}
 #pragma omp ordered depend(sink : i, j, k) // expected-error {{unexpected expression: number of expressions is larger than the number of associated loops}}
 #pragma omp ordered depend(sink : i+foo(), j/4) // expected-error {{expression is not an integral constant expression}} expected-error {{expected '+' or '-' operation}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{non-constexpr function 'foo' cannot be used in a constant expression}}
+#endif
 #pragma omp ordered depend(sink : i*0, j-4)// expected-error {{expected '+' or '-' operation}}
 #pragma omp ordered depend(sink : i-0, j+sizeof(int)) depend(sink : i-0, j+sizeof(int))
 #pragma omp ordered depend(sink : i-0, j+sizeof(int)) depend(source) // expected-error {{'depend(source)' clause cannot be mixed with 'depend(sink:vec)' clauses}}
 #pragma omp ordered depend(source) depend(sink : i-0, j+sizeof(int)) // expected-error {{'depend(sink:vec)' clauses cannot be mixed with 'depend(source)' clause}}
     }
   }
 
   return foo<int>(); // expected-note {{in instantiation of function template specialization 'foo<int>' requested here}}
 }

test/OpenMP/target_parallel_for_collapse_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s
 
 void foo() {
 }
 
 bool foobool(int argc) {
+#if __cplusplus >= 201103L
+// expected-note@-2 4 {{declared here}}
+#endif
   return argc;
 }
 
 struct S1; // expected-note {{declared here}}
 
 template <class T, typename S, int N, int ST> // expected-note {{declared here}}
 T tmain(T argc, S **argv) { //expected-note 2 {{declared here}}
   #pragma omp target parallel for collapse // expected-error {{expected '(' after 'collapse'}}
T tmain(T argc, S **argv) { //expected-note 2 {{declared here}}
   #pragma omp target parallel for collapse (1)) // expected-warning {{extra tokens at the end of '#pragma omp target parallel for' are ignored}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp target parallel for collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp target parallel for', but found only 1}}
   // expected-error@+3 2 {{directive '#pragma omp target parallel for' cannot contain more than one 'collapse' clause}}
   // expected-error@+2 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
   // expected-error@+1 2 {{expression is not an integral constant expression}}
   #pragma omp target parallel for collapse (foobool(argc)), collapse (true), collapse (-5)
+#if __cplusplus >= 201103L
+// expected-note@-2 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp target parallel for collapse (S) // expected-error {{'S' does not refer to a value}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
-  // expected-error@+1 2 {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+  // expected-error@+4 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#else
+  // expected-error@+2 2 {{expression is not an integral constant expression}}
+#endif
   #pragma omp target parallel for collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp target parallel for collapse (1)
   for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp target parallel for collapse (N) // expected-error {{argument to 'collapse' clause must be a strictly positive integer value}}
   for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
   #pragma omp target parallel for collapse (2) // expected-note {{as specified in 'collapse' clause}}
   foo(); // expected-error {{expected 2 for loops after '#pragma omp target parallel for'}}
   return argc;
 }
 
 int main(int argc, char **argv) {
   #pragma omp target parallel for collapse // expected-error {{expected '(' after 'collapse'}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp target parallel for collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp target parallel for collapse () // expected-error {{expected expression}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp target parallel for collapse (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'collapse' clause}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp target parallel for', but found only 1}}
   #pragma omp target parallel for collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp target parallel for' are ignored}}  expected-note {{as specified in 'collapse' clause}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp target parallel for', but found only 1}}
   #pragma omp target parallel for collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   // expected-error@+3 {{expression is not an integral constant expression}}
   // expected-error@+2 2 {{directive '#pragma omp target parallel for' cannot contain more than one 'collapse' clause}}
   // expected-error@+1 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
   #pragma omp target parallel for collapse (foobool(argc)), collapse (true), collapse (-5) 
+#if __cplusplus >= 201103L
+// expected-note@-2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   #pragma omp target parallel for collapse (S1) // expected-error {{'S1' does not refer to a value}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
-  // expected-error@+1 {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+  // expected-error@+4 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#else
+  // expected-error@+2 {{expression is not an integral constant expression}}
+#endif
   #pragma omp target parallel for collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
   // expected-error@+3 {{statement after '#pragma omp target parallel for' must be a for loop}}
   // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}}
   #pragma omp target parallel for collapse(collapse(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}}
   foo();
   #pragma omp target parallel for collapse (2) // expected-note {{as specified in 'collapse' clause}}
   foo(); // expected-error {{expected 2 for loops after '#pragma omp target parallel for'}}
   // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}}
   return tmain<int, char, 1, 0>(argc, argv);
 }
 

test/OpenMP/target_parallel_for_ordered_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s
+// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s
 
 void foo() {
 }
 
 bool foobool(int argc) {
+#if __cplusplus >= 201103L
+// expected-note@-2 4 {{declared here}}
+#endif
   return argc;
 }
 
 struct S1; // expected-note {{declared here}}
 
 template <class T, typename S, int N, int ST> // expected-note {{declared here}}
 T tmain(T argc, S **argv) {                   //expected-note 2 {{declared here}}
 #pragma omp target parallel for ordered
#pragma omp target parallel for ordered(ST // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST];
 #pragma omp target parallel for ordered(1)) // expected-warning {{extra tokens at the end of '#pragma omp target parallel for' are ignored}}
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST];
 #pragma omp target parallel for ordered((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'ordered' clause}}
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp target parallel for', but found only 1}}
+#if __cplusplus >= 201103L
+// expected-note@+5 2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
 // expected-error@+3 2 {{directive '#pragma omp target parallel for' cannot contain more than one 'ordered' clause}}
 // expected-error@+2 2 {{argument to 'ordered' clause must be a strictly positive integer value}}
 // expected-error@+1 2 {{expression is not an integral constant expression}}
 #pragma omp target parallel for ordered(foobool(argc)), ordered(true), ordered(-5)
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST];
 #pragma omp target parallel for ordered(S) // expected-error {{'S' does not refer to a value}}
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST];
-// expected-error@+1 2 {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+  // expected-error@+4 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#else
+  // expected-error@+2 2 {{expression is not an integral constant expression}}
+#endif
 #pragma omp target parallel for ordered(argv[1] = 2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST];
 #pragma omp target parallel for ordered(1)
   for (int i = ST; i < N; i++)
     argv[0][i] = argv[0][i] - argv[0][i - ST];
 #pragma omp target parallel for ordered(N) // expected-error {{argument to 'ordered' clause must be a strictly positive integer value}}
   for (T i = ST; i < N; i++)
#pragma omp target parallel for ordered() // expected-error {{expected expression}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];
 #pragma omp target parallel for ordered(4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'ordered' clause}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4]; // expected-error {{expected 4 for loops after '#pragma omp target parallel for', but found only 1}}
 #pragma omp target parallel for ordered(2 + 2))      // expected-warning {{extra tokens at the end of '#pragma omp target parallel for' are ignored}}  expected-note {{as specified in 'ordered' clause}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];            // expected-error {{expected 4 for loops after '#pragma omp target parallel for', but found only 1}}
+#if __cplusplus >= 201103L
+// expected-note@+2 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
 #pragma omp target parallel for ordered(foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];
+#if __cplusplus >= 201103L
+// expected-note@+5 {{non-constexpr function 'foobool' cannot be used in a constant expression}}
+#endif
 // expected-error@+3 {{expression is not an integral constant expression}}
 // expected-error@+2 2 {{directive '#pragma omp target parallel for' cannot contain more than one 'ordered' clause}}
 // expected-error@+1 2 {{argument to 'ordered' clause must be a strictly positive integer value}}
 #pragma omp target parallel for ordered(foobool(argc)), ordered(true), ordered(-5)
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];
 #pragma omp target parallel for ordered(S1) // expected-error {{'S1' does not refer to a value}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];
-// expected-error@+1 {{expression is not an integral constant expression}}
+#if __cplusplus >= 201103L
+  // expected-error@+4 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
+#else
+  // expected-error@+2 {{expression is not an integral constant expression}}
+#endif
 #pragma omp target parallel for ordered(argv[1] = 2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (int i = 4; i < 12; i++)
     argv[0][i] = argv[0][i] - argv[0][i - 4];
 // expected-error@+3 {{statement after '#pragma omp target parallel for' must be a for loop}}
 // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}}
 #pragma omp target parallel for ordered(ordered(tmain < int, char, -1, -2 > (argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}}
   foo();
 #pragma omp target parallel for ordered(2) // expected-note {{as specified in 'ordered' clause}}
   foo();                            // expected-error {{expected 2 for loops after '#pragma omp target parallel for'}}
   // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}}
   return tmain<int, char, 1, 0>(argc, argv);
 }
 

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

test/SemaCXX/implicit-virtual-member-functions.cpp

 // RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %itanium_abi_triple -verify -std=c++11 %s
 // RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -triple %ms_abi_triple -DMSABI -verify -std=c++11 %s
+
 struct A {
   virtual ~A();
+#if __cplusplus >= 201103L
+// expected-note@-2 3 {{overridden virtual function is here}}
+#endif
 };
 
-struct B : A { // expected-error {{no suitable member 'operator delete' in 'B'}}
+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}}
+#ifdef MSABI
+// expected-note@-6 {{virtual destructor requires an unambiguous, accessible 'operator delete'}}
+#endif
+#endif
   virtual void f();
 
-  void operator delete (void *, int); // expected-note {{'operator delete' declared here}}
+  void operator delete (void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 };
 
 #ifdef MSABI
-B b; // expected-note {{implicit destructor for 'B' first required here}}
+B b;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'B' first required here}}
+#else
+// expected-error@-4 {{attempt to use a deleted function}}
+#endif
+
 #else
-void B::f() { // expected-note {{implicit destructor for 'B' first required here}}
+void B::f() {
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'B' first required here}}
+#endif
 }
 #endif
 
-struct C : A { // expected-error {{no suitable member 'operator delete' in 'C'}}
+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}}
+#endif
+
   C();
-  void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
+  void operator delete(void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 };
 
-C::C() { }  // expected-note {{implicit destructor for 'C' first required here}}
+C::C() { }
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'C' first required here}}
+#endif
 
-struct D : A { // expected-error {{no suitable member 'operator delete' in 'D'}}
-  void operator delete(void *, int); // expected-note {{'operator delete' declared here}}
+struct D : A {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{no suitable member 'operator delete' in 'D'}}
+#else
+// expected-error@-4 {{deleted function '~D' cannot override a non-deleted function}}
+#endif
+  void operator delete(void *, int);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{'operator delete' declared here}}
+#endif
 }; 
 
 void f() {
-  new D; // expected-note {{implicit destructor for 'D' first required here}}
+  new D;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor for 'D' first required here}}
+#endif
 }

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
 {
   // A special new, to verify that the global version isn't used.
   void* operator new(size_t, S*); // expected-note {{candidate}}
 };
 struct V : U
 {
 };
 
 inline void operator delete(void *); // expected-warning {{replacement function 'operator delete' cannot be declared 'inline'}}
+#if __cplusplus >= 201103L
+// expected-warning@-2 {{function previously declared with an explicit exception specification redeclared with an implicit exception specification}}
+#endif
 
 __attribute__((used))
 inline void *operator new(size_t) { // no warning, due to __attribute__((used))
   return 0;
 }
 
 // PR5823
 void* operator new(const size_t); // expected-note 2 {{candidate}}

 };
 
 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[-1];
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{array size is negative}}
+#else
+  // expected-warning@-4 {{array size is negative}}
+#endif
+
+  (void)new int[2000000000];
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{array is too large}}
+#else
+  // expected-warning@-4 {{array is too large}}
+#endif
+
+  (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 {{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}}
 }

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.

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}}
+#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}}
+#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() { }

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 {};

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;
 }

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>;

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 { };
 }
 

 // wanted to write an explicit specialization, but forgot the '<>'
 // after 'template'.
 template class X0<double> { }; // expected-error{{explicit specialization}}
 
 // Check for explicit instantiations that come after other kinds of
 // instantiations or declarations.
 template class X0<int, int>; // expected-error{{duplicate}}
 
-template<> class X0<char> { }; // expected-note{{previous}}
-template class X0<char>; // expected-warning{{ignored}}
+template<> class X0<char> { };
+#if __cplusplus <= 199711L
+// expected-note@-2 {{previous template specialization is here}}
+#endif
+
+template class X0<char>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'X0<char, char>' that occurs after an explicit specialization will be ignored (C++11 extension)}}
+#endif
 
 void foo(X0<short>) { }
 template class X0<short>;
 
 // Check that explicit instantiations actually produce definitions. We
 // determine whether this happens by placing semantic errors in the
 // definition of the template we're instantiating.
 template<typename T> struct X2; // expected-note{{declared here}}

 
 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
 }

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));
 }

test/SemaTemplate/virtual-member-functions.cpp

 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++98 %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -std=c++98 -verify %s
+// RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -std=c++11 -verify %s
 
 namespace PR5557 {
 template <class T> struct A {
   A(); // expected-note{{instantiation}}
   virtual int a(T x);
 };
 template<class T> A<T>::A() {}
 

 
 HasOutOfLineKey<int> out_of_line; // expected-note{{in instantiation of member function 'HasOutOfLineKey<int>::HasOutOfLineKey' requested here}}
 
 namespace std {
   class type_info;
 }
 
 namespace PR7114 {
-  class A { virtual ~A(); }; // expected-note{{declared private here}}
+  class A { virtual ~A(); };
+#if __cplusplus <= 199711L
+  // expected-note@-2{{declared private here}}
+#else
+  // expected-note@-4 3 {{overridden virtual function is here}}
+#endif
 
   template<typename T>
   class B {
   public:
-    class Inner : public A { }; // expected-error{{base class 'PR7114::A' has private destructor}}
+    class Inner : public A { };
+#if __cplusplus <= 199711L
+// expected-error@-2{{base class 'PR7114::A' has private destructor}}
+#else
+// expected-error@-4 2 {{deleted function '~Inner' cannot override a non-deleted function}}
+#ifdef MSABI
+// expected-note@-6 1 {{destructor of 'Inner' is implicitly deleted because base class 'PR7114::A' has an inaccessible destructor}}
+#endif
+#endif
+
     static Inner i;
     static const unsigned value = sizeof(i) == 4;
+#if __cplusplus >= 201103L
+// expected-note@-2 {{in instantiation of member class 'PR7114::B<int>::Inner' requested here}}
+// expected-note@-3 {{in instantiation of member class 'PR7114::B<float>::Inner' requested here}}
+#endif
   };
 
   int f() { return B<int>::value; }
+#if __cplusplus >= 201103L
+// expected-note@-2 {{in instantiation of template class 'PR7114::B<int>' requested here}}
+#endif
 
 #ifdef MSABI
-  void test_typeid(B<float>::Inner bfi) { // expected-note{{implicit destructor}}
+  void test_typeid(B<float>::Inner bfi) {
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor}}
+#else
+// expected-error@-4 {{attempt to use a deleted function}}
+// expected-note@-5 {{in instantiation of template class 'PR7114::B<float>' requested here}}
+#endif
+
     (void)typeid(bfi);
 #else
   void test_typeid(B<float>::Inner bfi) {
-    (void)typeid(bfi); // expected-note{{implicit destructor}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{in instantiation of template class 'PR7114::B<float>' requested here}}
+#endif
+    (void)typeid(bfi);
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit destructor}}
+#endif
 #endif
   }
 
   template<typename T>
   struct X : A {
+#if __cplusplus >= 201103L
+// expected-error@-2{{deleted function '~X' cannot override a non-deleted function}}
+#endif
     void f() { }
   };
 
   void test_X(X<int> &xi, X<float> &xf) {
     xi.f();
+#if __cplusplus >= 201103L
+// expected-note@-2 {{in instantiation of template class 'PR7114::X<int>' requested here}}
+#endif
   }
 }
 
 namespace DynamicCast {
   struct Y {};
   template<typename T> struct X : virtual Y {
     virtual void foo() { T x; }
   };