Lit C++11 Compatibility Patch #7

[tigerleapgorge]

Summary

13 tests have been updated for C++11 compatibility.

CXX/class.access/class.access.dcl/p1.cpp

Access declarations are deprecated in C++11.
As a result, there are 4 types of diagnostics changes:

For simple access declarations, there is a change in diagnostics.
  C++98: warning: access declarations are deprecated; use using declarations instead
  C++11: error: ISO C++11 does not allow access declarations; use using declarations instead

For Self-referential access declarations, there is also an additional error message.
  C++98: warning: access declarations are deprecated; use using declarations instead
  C++11: error: ISO C++11 does not allow access declarations; use using declarations instead
  C++11: error: using declaration refers to its own class

For an access declaration of a non-base method, there is a different additional error message.
  C++98: warning: access declarations are deprecated; use using declarations instead
  C++11: error: ISO C++11 does not allow access declarations; use using declarations instead
  C++11: error: using declaration refers into 'Subclass::', which is not a base class of 'C'

For self-referential access declaration with local declaration, there is the additional error message but one less note message.
  C++98: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]
  C++98: error: using declaration refers to its own class
  C++98: note: target of using declaration
  C++11: error: ISO C++11 does not allow access declarations; use using declarations instead
  C++11: error: using declaration refers to its own class

CXX/temp/temp.spec/temp.expl.spec/p2.cpp

Guard multiple instances of the following diagnostics to C++98.
  C++98: warning: first declaration of function template specialization of 'f0' outside namespace 'N0' is a C++11 extension
  C++98: note: explicitly specialized declaration is here

CXX/temp/temp.spec/temp.expl.spec/p3.cpp

Guard one instance of the following diagnostics to C++98.
  C++98: warning: first declaration of class template specialization of 'X' outside namespace 'N' is a C++11 extension
  C++98: note: explicitly specialized declaration is here

CXX/temp/temp.spec/temp.explicit/p2.cpp
CXX/temp/temp.spec/temp.explicit/p5.cpp

In C++98 with -Wc++11-compat, Out-of-scope explicit instantiations of template is a Warning.
In C++11, it is now an Error.
  C++98: warning: explicit instantiation of 'N::f1' must occur in namespace 'N'
  C++11: error: explicit instantiation of 'N::f1' must occur in namespace 'N'

CodeGenCXX/debug-info-static-member.cpp

In C++11, replace “const” with “constexpr” for in-class static initializer of non-integral type.
Otherwise compiler would complain: 
  C++11: error: in-class initializer for static data member of type 'const float' requires 'constexpr' specifier

SemaCXX/dcl_init_aggr.cpp

Diagnostic change due to initializer list
  C++98: error: non-aggregate type 'NonAggregate' cannot be initialized with an initializer list
  C++11: error no matching constructor for initialization of 'NonAggregate'
         note: candidate constructor (the implicit copy constructor) not viable
         note: candidate constructor (the implicit move constructor) not viable
         note: candidate constructor not viable

Diagnostic Change
  C++98: conversion from string literal to 'char *' is deprecated
  C++11: ISO C++11 does not allow conversion from string literal to 'char *'

Addition C++11 move constructor diagnostics
  C++11: note: candidate constructor (the implicit move constructor) not viable

The next 2 lines caused a lot of diff.
  Source: TooFewError too_few_error = { 1 }
  C++98: error: no matching constructor for initialization of 'NoDefaultConstructor'
         note: candidate constructor not viable: requires 1 argument, but 0 were provided
         note: candidate constructor (the implicit copy constructor) not viable
         note: in implicit initialization of field 'nodef' with omitted initializer
         error: implicit default constructor for 'TooFewError' must explicitly initialize
                the member 'nodef' which does not have a default constructor
         note: member is declared here
         note: 'NoDefaultConstructor' declared here

  C++11: error: no matching constructor for initialization of 'NoDefaultConstructor'
         note: candidate constructor not viable: requires 1 argument, but 0 were provided
         note: candidate constructor (the implicit copy constructor) not viable
         note: candidate constructor (the implicit move constructor) not viable
         note: in implicit initialization of field 'nodef' with omitted initializer

  Source: TooFewError too_few_okay2[2] = { 1, 1 };
  C++98: note: implicit default constructor for 'TooFewError' first required here
         note: 'NoDefaultConstructor' declared her
  C++11: error: no matching constructor for initialization of 'NoDefaultConstructor'
        note: candidate constructor not viable: requires 1 argument, but 0 were provided
         note: candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided
         note: candidate constructor (the implicit move constructor) not viable: requires 1 argument, but 0 were provided
         note: in implicit initialization of field 'nodef' with omitted initializer
         note: in implicit initialization of array element 1 with omitted initializer

SemaCXX/type-convert-construct.cpp

*Note: Run line used “–std=gnu++XX” instead of “c++” due to use of “typeof”.
New C++11 error message for int and pointer comparison
  C++11: error: comparison between pointer and integer ('T' (aka 'int') and 'int *')

Change in diagnostics:
  C++98: Warning: conversion from string literal to 'char *' is deprecated
  C++11: Warning: ISO C++11 does not allow conversion from string literal to 'char *'

  C++98: Warning: conversion from string literal to 'wchar_t *' is deprecated
  C++11: Warning: ISO C++11 does not allow conversion from string literal to 'wchar_t

SemaCXX/vararg-non-pod.cpp

Clang in C++11 now allows non-POD type to be passed via variadic argument.
However, Clang still does not allow non-trivial type to be passed 
(according C++11 standard 5.2.2\7 [expr.call] this behavior is “implementation defined”)

Restrict the following warnings on non-POD types to C++98/03
  C++98: warning: cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime
  C++98: warning: cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime
  C++98: warning: cannot pass object of non-POD type 'C' through variadic block; call will abort at runtime
  C++98: warning: cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime

Change in diagnostics for non-trivial type
  C++98: warning: cannot pass object of non-POD type 'Base' through variadic function; call will abort at runtime
  C++11: warning: cannot pass object of non-trivial type 'Base' through variadic function; call will abort at runtime

SemaTemplate/class-template-spec.cpp

Restrict the following diagnostics to C++98/03

  C++98: warning: first declaration of class template specialization of 'B' outside namespace 'N' is a C++11 extension 
         note: explicitly specialized declaration is here

  C++98: Warning: variadic templates are a C++11 extension

  C++98: Warning: alias declarations are a C++11 extension

SemaTemplate/instantiate-cast.cpp

When there is no matching conversion, C++98 tries copy and default constructors 
whereas C++11 tries copy, move and default constructors.
Therefore, there is one additional move constructor Note message in C++11
  C++11: note: candidate constructor (the implicit copy constructor) not viable: 
               no known conversion from 'int' to 'const A' for 1st argument

SemaTemplate/instantiate-expr-4.cpp

Added C++11 specific diagnostics 
3 instances of move constructor diagnostics 
  C++11:  candidate constructor (the implicit move constructor) not viable

1 instance of initializer list narrowing diagnostics
  C++11: error: type 'float' cannot be narrowed to 'int' in initializer list
         note: in instantiation of member function 'InitList1<int [1], float>::f' requested here
         note: insert an explicit cast to silence this issue

SemaTemplate/instantiate-member-class.cpp

Guard C++98/03 Specific warning
  C++98:  Warning: alias declarations are a C++11 extension

Change in diagnostics, C++98/03 allows for ‘0’ to null pointer conversion during initialization, C++11 does not. 
  C++98: warning: expression which evaluates to zero treated as a null pointer constant of type 'int *'
  C++11: Error: cannot initialize a variable of type 'int *' with an rvalue of type 'int'

cfe/trunk/test/CXX/class.access/class.access.dcl/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
 
 // This is just the test for [namespace.udecl]p4 with 'using'
 // uniformly stripped out.
 
 // 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
namespace NonClass {
     typedef int type;
     struct hiding {};
     int hiding;
     static union { double union_member; };
     enum tagname { enumerator };
   }
 
   class Test0 {
-    NonClass::type; // expected-error {{not a class}} expected-warning {{access declarations are deprecated}}
-    NonClass::hiding; // expected-error {{not a class}} expected-warning {{access declarations are deprecated}}
-    NonClass::union_member; // expected-error {{not a class}} expected-warning {{access declarations are deprecated}}
-    NonClass::enumerator; // expected-error {{not a class}} expected-warning {{access declarations are deprecated}}
+    NonClass::type; // expected-error {{not a class}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    NonClass::hiding; // expected-error {{not a class}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    NonClass::union_member; // expected-error {{not a class}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    NonClass::enumerator; // expected-error {{not a class}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
   };
 }
 
 struct Opaque0 {};
 
 namespace test1 {
   struct A {
     typedef int type;
     struct hiding {}; // expected-note {{previous use is here}}
     Opaque0 hiding;
     union { double union_member; };
     enum tagname { enumerator };
   };
 
   struct B : A {
-    A::type; // expected-warning {{access declarations are deprecated}}
-    A::hiding; // expected-warning {{access declarations are deprecated}}
-    A::union_member; // expected-warning {{access declarations are deprecated}}
-    A::enumerator; // expected-warning {{access declarations are deprecated}}
-    A::tagname; // expected-warning {{access declarations are deprecated}}
+    A::type;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+    A::hiding;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A::union_member;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A::enumerator;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A::tagname;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
 
     void test0() {
       type t = 0;
     }
 
     void test1() {
       typedef struct A::hiding local;
       struct hiding _ = local();
struct A {
     typedef int type;
     struct hiding {}; // expected-note {{previous use is here}}
     int hiding;
     union { double union_member; };
     enum tagname { enumerator };
   };
 
   template <class T> struct B : A {
-    A::type; // expected-warning {{access declarations are deprecated}}
-    A::hiding; // expected-warning {{access declarations are deprecated}}
-    A::union_member; // expected-warning {{access declarations are deprecated}}
-    A::enumerator; // expected-warning {{access declarations are deprecated}}
-    A::tagname; // expected-warning {{access declarations are deprecated}}
+    A::type;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A::hiding;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A::union_member;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A::enumerator;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A::tagname;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
 
     void test0() {
       type t = 0;
     }
 
     void test1() {
       typedef struct A::hiding local;
       struct hiding _ = local();
template <class T> struct A {
     typedef int type; // expected-note {{target of using declaration}}
     struct hiding {};
     Opaque0 hiding;
     union { double union_member; };
     enum tagname { enumerator }; // expected-note {{target of using declaration}}
   };
 
   template <class T> struct B : A<T> {
-    A<T>::type; // expected-error {{dependent using declaration resolved to type without 'typename'}} // expected-warning {{access declarations are deprecated}}
-    A<T>::hiding; // expected-warning {{access declarations are deprecated}}
-    A<T>::union_member; // expected-warning {{access declarations are deprecated}}
-    A<T>::enumerator; // expected-warning {{access declarations are deprecated}}
-    A<T>::tagname; // expected-error {{dependent using declaration resolved to type without 'typename'}} // expected-warning {{access declarations are deprecated}}
+    A<T>::type; // expected-error {{dependent using declaration resolved to type without 'typename'}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A<T>::hiding;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A<T>::union_member;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A<T>::enumerator;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    A<T>::tagname; // expected-error {{dependent using declaration resolved to type without 'typename'}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
 
     // FIXME: re-enable these when the various bugs involving tags are fixed
 #if 0
     void test1() {
       typedef struct A<T>::hiding local;
       struct hiding _ = local();
     }
 
namespace test4 {
   };
 
   namespace InnerNS {
     int foo();
   }
 
   // We should be able to diagnose these without instantiation.
   template <class T> struct C : Base {
-    InnerNS::foo; // expected-error {{not a class}} expected-warning {{access declarations are deprecated}}
-    Base::bar; // expected-error {{no member named 'bar'}} expected-warning {{access declarations are deprecated}}
-    Unrelated::foo; // expected-error {{not a base class}} expected-warning {{access declarations are deprecated}}
-    C::foo; // legal in C++03 // expected-warning {{access declarations are deprecated}}
-    Subclass::foo; // legal in C++03 // expected-warning {{access declarations are deprecated}}
+    InnerNS::foo; // expected-error {{not a class}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    Base::bar; // expected-error {{no member named 'bar'}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
 
-    int bar(); //expected-note {{target of using declaration}}
-    C::bar; // expected-error {{refers to its own class}} expected-warning {{access declarations are deprecated}}
+    Unrelated::foo; // expected-error {{not a base class}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+
+    C::foo; // legal in C++03
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+    // expected-error@-5 {{using declaration refers to its own class}}
+#endif
+
+    Subclass::foo; // legal in C++03
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+    // expected-error@-5 {{using declaration refers into 'Subclass::', which is not a base class of 'C'}}
+#endif
+
+    int bar();
+#if __cplusplus <= 199711L
+    //expected-note@-2 {{target of using declaration}}
+#endif
+    C::bar;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{access declarations are deprecated; use using declarations instead}}
+#else
+    // expected-error@-4 {{ISO C++11 does not allow access declarations; use using declarations instead}}
+#endif
+    // expected-error@-6 {{using declaration refers to its own class}}
   };
 }
 

cfe/trunk/test/CXX/temp/temp.spec/temp.expl.spec/p2.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
+
 
 // This test creates cases where implicit instantiations of various entities
 // would cause a diagnostic, but provides expliict specializations for those
 // entities that avoid the diagnostic. The specializations are alternately
 // declarations and definitions, and the intent of this test is to verify
 // that we allow specializations only in the appropriate namespaces (and
 // nowhere else).
 struct NonDefaultConstructible {
   NonDefaultConstructible(int);
 };
 
 
 // C++ [temp.expl.spec]p1:
 //   An explicit specialization of any of the following:
 
 //     -- function template
 namespace N0 {
-  template<typename T> void f0(T) { // expected-note{{here}}
+  template<typename T> void f0(T) {
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{explicitly specialized declaration is here}}
+#endif
     T t;
   }
 
   template<> void f0(NonDefaultConstructible) { }
 
   void test_f0(NonDefaultConstructible NDC) {
     f0(NDC);
   }
   
   template<> void f0(int);
   template<> void f0(long);
 }
 
 template<> void N0::f0(int) { } // okay
 
 namespace N1 {
   template<> void N0::f0(long) { } // expected-error{{does not enclose namespace}}
 }
 
-template<> void N0::f0(double); // expected-warning{{C++11 extension}}
+template<> void N0::f0(double);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of function template specialization of 'f0' outside namespace 'N0' is a C++11 extension}}
+#endif
+
 template<> void N0::f0(double) { }
 
 struct X1 {
   template<typename T> void f(T);
   
   template<> void f(int); // expected-error{{in class scope}}
 };
 
 //     -- class template
 namespace N0 {
   
 template<typename T>
-struct X0 { // expected-note 2{{here}}
-  static T member; // expected-note{{here}}
-  
-  void f1(T t) { // expected-note{{explicitly specialized declaration is here}}
+struct X0 { // expected-note {{explicitly specialized declaration is here}}
+#if __cplusplus <= 199711L
+// expected-note@-2 {{explicitly specialized declaration is here}}
+#endif
+  static T member;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{explicitly specialized declaration is here}}
+#endif
+  
+  void f1(T t) {
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{explicitly specialized declaration is here}}
+#endif
     t = 17;
   }
   
-  struct Inner : public T { }; // expected-note 3{{here}}
+  struct Inner : public T { }; // expected-note 2{{explicitly specialized declaration is here}}
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{explicitly specialized declaration is here}}
+#endif
   
   template<typename U>
-  struct InnerTemplate : public T { }; // expected-note 2{{explicitly specialized}} \
-   // expected-error{{base specifier}}
+  struct InnerTemplate : public T { }; // expected-note {{explicitly specialized declaration is here}}
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{explicitly specialized declaration is here}}
+#endif
+  // expected-error@-4 {{base specifier must name a class}}
   
   template<typename U>
-  void ft1(T t, U u); // expected-note{{explicitly specialized}}
+  void ft1(T t, U u);
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{explicitly specialized declaration is here}}
+#endif
 };
 
 }
 
 template<typename T> 
 template<typename U>
 void N0::X0<T>::ft1(T t, U u) {
   t = u;
 }
 
 template<typename T> T N0::X0<T>::member;
 
-template<> struct N0::X0<void> { }; // expected-warning{{C++11 extension}}
+template<> struct N0::X0<void> { };
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of class template specialization of 'X0' outside namespace 'N0' is a C++11 extension}}
+#endif
 N0::X0<void> test_X0;
 
 namespace N1 {
   template<> struct N0::X0<const void> { }; // expected-error{{not in a namespace enclosing 'N0'}}
 }
 
 namespace N0 {
   template<> struct X0<volatile void>;
 }
 
 template<> struct N0::X0<volatile void> { 
   void f1(void *);
 };
 
 //     -- member function of a class template
-template<> void N0::X0<void*>::f1(void *) { } // expected-warning{{member function specialization}}
+template<> void N0::X0<void*>::f1(void *) { }
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of member function specialization of 'f1' outside namespace 'N0' is a C++11 extension}}
+#endif
 
 void test_spec(N0::X0<void*> xvp, void *vp) {
   xvp.f1(vp);
 }
 
 namespace N0 {
   template<> void X0<volatile void>::f1(void *) { } // expected-error{{no function template matches}}
 
namespace N0 {
   
   template<> double X0<double>::member;
 }
 
 NonDefaultConstructible &get_static_member() {
   return N0::X0<NonDefaultConstructible>::member;
 }
 
-template<> int N0::X0<int>::member;  // expected-warning{{C++11 extension}}
+template<> int N0::X0<int>::member;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of static data member specialization of 'member' outside namespace 'N0' is a C++11 extension}}
+#endif
 
 template<> float N0::X0<float>::member = 3.14f;
 
 namespace N1 {
   template<> double N0::X0<double>::member = 3.14; // expected-error{{does not enclose namespace}}
 }
 
 //    -- member class of a class template
namespace N0 {
   template<>
   struct X0<float>::Inner;
 
   template<>
   struct X0<double>::Inner; // expected-note{{forward declaration}}
 }
 
 template<>
-struct N0::X0<long>::Inner { }; // expected-warning{{C++11 extension}}
+struct N0::X0<long>::Inner { };
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of member class specialization of 'Inner' outside namespace 'N0' is a C++11 extension}}
+#endif
 
 template<>
 struct N0::X0<float>::Inner { };
 
 namespace N1 {
   template<>
   struct N0::X0<unsigned>::Inner { }; // expected-error{{member class specialization}}
 
namespace N0 {
   template<> template<>
   struct X0<int>::InnerTemplate<double>;
 }
 
 template<> template<>
 struct N0::X0<int>::InnerTemplate<long> { }; // okay
 
 template<> template<>
-struct N0::X0<int>::InnerTemplate<float> { }; // expected-warning{{class template specialization}}
+struct N0::X0<int>::InnerTemplate<float> { };
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of class template specialization of 'InnerTemplate' outside namespace 'N0' is a C++11 extension}}
+#endif
 
 namespace N1 {
   template<> template<>
   struct N0::X0<int>::InnerTemplate<double> { }; // expected-error{{enclosing}}
 }
 
 N0::X0<void*>::InnerTemplate<int> inner_template0;
 N0::X0<int>::InnerTemplate<int> inner_template1; // expected-error{{incomplete}}
namespace N0 {
   template<> template<>
   void X0<void*>::ft1(void *, long);
 }
 
 template<> template<>
 void N0::X0<void*>::ft1(void *, unsigned) { } // okay
 
 template<> template<>
-void N0::X0<void*>::ft1(void *, float) { } // expected-warning{{function template specialization}}
+void N0::X0<void*>::ft1(void *, float) { }
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of function template specialization of 'ft1' outside namespace 'N0' is a C++11 extension}}
+#endif
 
 namespace N1 {
   template<> template<>
   void N0::X0<void*>::ft1(void *, long) { } // expected-error{{does not enclose namespace}}
 }
 
 
 void test_func_template(N0::X0<void *> xvp, void *vp, const void *cvp,

cfe/trunk/test/CXX/temp/temp.spec/temp.expl.spec/p3.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 N {
-  template<class T> class X; // expected-note {{'N::X' declared here}} \
-                             // expected-note {{explicitly specialized declaration is here}}
+  template<class T> class X; // expected-note {{'N::X' declared here}}
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{explicitly specialized declaration is here}}
+#endif
 }
 
 // TODO: Don't add a namespace qualifier to the template if it would trigger
 // the warning about the specialization being outside of the namespace.
-template<> class X<int> { /* ... */ };  // expected-error {{no template named 'X'; did you mean 'N::X'?}} \
-                                        // expected-warning {{first declaration of class template specialization of 'X' outside namespace 'N' is a C++11 extension}}
+template<> class X<int> { /* ... */ };  // expected-error {{no template named 'X'; did you mean 'N::X'?}}
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of class template specialization of 'X' outside namespace 'N' is a C++11 extension}}
+#endif
 
 namespace N {
   
 template<> class X<char*> { /* ... */ };  // OK: X is a template
   
 }

cfe/trunk/test/CXX/temp/temp.spec/temp.explicit/p2.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++98 -Wc++11-compat %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
 
 // Example from the standard
 template<class T> class Array { void mf() { } }; 
 
 template class Array<char>; 
 template void Array<int>::mf();
 template<class T> void sort(Array<T>& v) { /* ... */ }
 template void sort(Array<char>&);
namespace N {
   struct X1 { // expected-note{{explicit instantiation refers here}}
   };
   
   template<typename T>
   void f1(T) {} // expected-note{{explicit instantiation refers here}}
 }
 using namespace N;
 
-template struct X1<int>; // expected-warning{{must occur in}}
-template void f1(int); // expected-warning{{must occur in}}
+template struct X1<int>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'N::X1' must occur in namespace 'N'}}
+#else
+// expected-error@-4 {{explicit instantiation of 'N::X1' must occur in namespace 'N'}}
+#endif
+
+template void f1(int);
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'N::f1' must occur in namespace 'N'}}
+#else
+// expected-error@-4 {{explicit instantiation of 'N::f1' must occur in namespace 'N'}}
+#endif

cfe/trunk/test/CXX/temp/temp.spec/temp.explicit/p5.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wc++11-compat %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 -Wc++11-compat %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 namespace N {
   template<class T> class Y { // expected-note{{explicit instantiation refers here}}
     void mf() { } 
   };
 }
 
 template class Z<int>; // expected-error{{explicit instantiation of non-template class 'Z'}}
 
 // FIXME: This example from the standard is wrong; note posted to CWG reflector
 // on 10/27/2009
 using N::Y; 
-template class Y<int>; // expected-warning{{must occur in}}
+template class Y<int>;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{explicit instantiation of 'N::Y' must occur in namespace 'N'}}
+#else
+// expected-error@-4 {{explicit instantiation of 'N::Y' must occur in namespace 'N'}}
+#endif
 
 template class N::Y<char*>; 
 template void N::Y<double>::mf();

cfe/trunk/test/CodeGenCXX/debug-info-static-member.cpp

 // RUN: %clangxx -target x86_64-unknown-unknown -g %s -emit-llvm -S -o - | FileCheck %s
+// RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++98 %s -emit-llvm -S -o - | FileCheck %s
+// RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++11 %s -emit-llvm -S -o - | FileCheck %s
 // PR14471
 
 enum X {
   Y
 };
 class C
 {
   static int a;
   const static bool const_a = true;
 protected:
   static int b;
+#if __cplusplus >= 201103L
+  constexpr static float const_b = 3.14;
+#else
   const static float const_b = 3.14;
+#endif
 public:
   static int c;
   const static int const_c = 18;
   int d;
   static X x_a;
 };
 
 int C::a = 4;

cfe/trunk/test/SemaCXX/dcl_init_aggr.cpp

 // RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
+// RUN: %clang_cc1 -fsyntax-only -pedantic -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -pedantic -verify -std=c++11 %s
 // C++ [dcl.init.aggr]p2
 struct A { 
   int x;
   struct B { 
     int i;
     int j;
   } b; 
 } a1 = { 1, { 2, 3 } };
 
 struct NonAggregate {
+#if __cplusplus >= 201103L
+// expected-note@-2 3 {{candidate constructor (the implicit copy constructor) not viable}}
+// expected-note@-3 3 {{candidate constructor (the implicit move constructor) not viable}}
+#endif
   NonAggregate();
-
+#if __cplusplus >= 201103L
+// expected-note@-2 3 {{candidate constructor not viable: requires 0 arguments, but 2 were provided}}
+#endif
   int a, b;
 };
-NonAggregate non_aggregate_test = { 1, 2 }; // expected-error{{non-aggregate type 'NonAggregate' cannot be initialized with an initializer list}}
-
-NonAggregate non_aggregate_test2[2] = { { 1, 2 }, { 3, 4 } }; // expected-error 2 {{non-aggregate type 'NonAggregate' cannot be initialized with an initializer list}}
-
+NonAggregate non_aggregate_test = { 1, 2 };
+#if __cplusplus <= 199711L
+// expected-error@-2 {{non-aggregate type 'NonAggregate' cannot be initialized with an initializer list}}
+#else
+// expected-error@-4 {{no matching constructor for initialization of 'NonAggregate'}}
+#endif
+
+NonAggregate non_aggregate_test2[2] = { { 1, 2 }, { 3, 4 } };
+#if __cplusplus <= 199711L
+// expected-error@-2 2 {{non-aggregate type 'NonAggregate' cannot be initialized with an initializer list}}
+#else
+// expected-error@-4 2 {{no matching constructor for initialization of 'NonAggregate'}}
+#endif
 
 // C++ [dcl.init.aggr]p3
 A a_init = A(); 
 
 // C++ [dcl.init.aggr]p4
 int x[] = { 1, 3, 5 };
 int x_sizecheck[(sizeof(x) / sizeof(int)) == 3? 1 : -1];
 int x2[] = { }; // expected-warning{{zero size arrays are an extension}}
 
 // C++ [dcl.init.aggr]p5
 struct StaticMemberTest {
   int i;
   static int s;
   int *j;
 } smt = { 1, &smt.i };
 
 // C++ [dcl.init.aggr]p6
 char cv[4] = { 'a', 's', 'd', 'f', 0 }; // expected-error{{excess elements in array initializer}}
 
 // C++ [dcl.init.aggr]p7
 struct TooFew { int a; char* b; int c; }; 
-TooFew too_few = { 1, "asdf" }; // expected-warning{{conversion from string literal to 'char *' is deprecated}}
+TooFew too_few = { 1, "asdf" };
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
+#else
+// expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'char *'}}
+#endif
+
+struct NoDefaultConstructor {
+#if __cplusplus <= 199711L
+// expected-note@-2 3 {{candidate constructor (the implicit copy constructor)}}
+// expected-note@-3 {{declared here}}
+#else
+// expected-note@-5 4 {{candidate constructor (the implicit copy constructor)}}
+// expected-note@-6 4 {{candidate constructor (the implicit move constructor)}}
+#endif
+
+  NoDefaultConstructor(int);
+#if __cplusplus <= 199711L
+  // expected-note@-2 3 {{candidate constructor not viable: requires 1 argument, but 0 were provided}}
+#else
+  // expected-note@-4 4 {{candidate constructor not viable: requires 1 argument, but 0 were provided}}
+#endif
+
+};
+struct TooFewError {
+#if __cplusplus <= 199711L
+// expected-error@-2 {{implicit default constructor for}}
+#endif
 
-struct NoDefaultConstructor { // expected-note 3 {{candidate constructor (the implicit copy constructor)}} \
-                              // expected-note{{declared here}}
-  NoDefaultConstructor(int); // expected-note 3 {{candidate constructor}}
-};
-struct TooFewError { // expected-error{{implicit default constructor for}}
   int a;
-  NoDefaultConstructor nodef; // expected-note{{member is declared here}} expected-note 2{{in implicit initialization of field 'nodef'}}
+  NoDefaultConstructor nodef;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{member is declared here}}
+// expected-note@-3 2{{in implicit initialization of field 'nodef' with omitted initializer}}
+#else
+// expected-note@-5 3{{in implicit initialization of field 'nodef' with omitted initializer}}
+#endif
 };
 TooFewError too_few_okay = { 1, 1 };
 TooFewError too_few_error = { 1 }; // expected-error{{no matching constructor}}
 
-TooFewError too_few_okay2[2] = { 1, 1 }; // expected-note{{implicit default constructor for 'TooFewError' first required here}}
+TooFewError too_few_okay2[2] = { 1, 1 };
+#if __cplusplus <= 199711L
+// expected-note@-2 {{implicit default constructor for 'TooFewError' first required here}}
+#else
+// expected-error@-4 {{no matching constructor for initialization of 'NoDefaultConstructor'}}
+// expected-note@-5 {{in implicit initialization of array element 1 with omitted initializer}}
+#endif
+
 TooFewError too_few_error2[2] = { 1 }; // expected-error{{no matching constructor}}
 
 NoDefaultConstructor too_few_error3[3] = { }; // expected-error {{no matching constructor}} expected-note {{implicit initialization of array element 0}}
 
 // C++ [dcl.init.aggr]p8
 struct Empty { };
 struct EmptyTest {
   Empty s;

 C2 c2; 
 D2 d2;
 B2 b2 = { 4, a2, a2 };
 B2 b2_2 = { 4, d2, 0 };
 B2 b2_3 = { c2, a2, a2 };
 
 // C++ [dcl.init.aggr]p15:
 union u { int a; char* b; }; // expected-note{{candidate constructor (the implicit copy constructor)}}
+#if __cplusplus >= 201103L
+// expected-note@-2 {{candidate constructor (the implicit move constructor)}}
+#endif
+
 u u1 = { 1 }; 
 u u2 = u1; 
 u u3 = 1; // expected-error{{no viable conversion}}
 u u4 = { 0, "asdf" };  // expected-error{{excess elements in union initializer}}
 u u5 = { "asdf" }; // expected-error{{cannot initialize a member subobject of type 'int' with an lvalue of type 'const char [5]'}}

cfe/trunk/test/SemaCXX/type-convert-construct.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s 
+// RUN: %clang_cc1 -fsyntax-only -verify -std=gnu++98 %s 
+// RUN: %clang_cc1 -fsyntax-only -verify -std=gnu++11 %s 
 
 void f() {
   float v1 = float(1);
   int v2 = typeof(int)(1,2); // expected-error {{excess elements in scalar initializer}}
   typedef int arr[];
   int v3 = arr(); // expected-error {{array types cannot be value-initialized}}
   typedef void fn_ty();
   fn_ty(); // expected-error {{function types cannot be value-initialized}}
   int v4 = int();
   int v5 = int; // expected-error {{expected '(' for function-style cast or type construction}}
   typedef int T;
   int *p;
   bool v6 = T(0) == p;
+#if __cplusplus >= 201103L
+  // expected-error@-2 {{comparison between pointer and integer ('T' (aka 'int') and 'int *')}}
+#endif
   char *str;
-  str = "a string"; // expected-warning{{conversion from string literal to 'char *' is deprecated}}
+  str = "a string";
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{conversion from string literal to 'char *' is deprecated}}
+#else
+  // expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'char *'}}
+#endif
   wchar_t *wstr;
-  wstr = L"a wide string"; // expected-warning{{conversion from string literal to 'wchar_t *' is deprecated}}
+  wstr = L"a wide string";
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{conversion from string literal to 'wchar_t *' is deprecated}}
+#else
+  // expected-warning@-4 {{ISO C++11 does not allow conversion from string literal to 'wchar_t *'}}
+#endif
 }

cfe/trunk/test/SemaCXX/vararg-non-pod.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s -Wno-error=non-pod-varargs
+// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=c++98 %s -Wno-error=non-pod-varargs
+// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=c++11 %s -Wno-error=non-pod-varargs
 
 // Check that the warning is still there under -fms-compatibility.
 // RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s -Wno-error=non-pod-varargs -fms-compatibility
+// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=c++98 %s -Wno-error=non-pod-varargs -fms-compatibility
+// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -std=c++11 %s -Wno-error=non-pod-varargs -fms-compatibility
 
 extern char version[];
 
 class C {
 public:
   C(int);
   void g(int a, ...);
   static void h(int a, ...);
 };
 
 void g(int a, ...);
 
 void t1()
 {
   C c(10);
   
-  g(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+  g(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+#endif
+
   g(10, version);
 
   void (*ptr)(int, ...) = g;
-  ptr(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+  ptr(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+#endif
+
   ptr(10, version);
 }
 
 void t2()
 {
   C c(10);
 
-  c.g(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+  c.g(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+#endif
+
   c.g(10, version);
 
   void (C::*ptr)(int, ...) = &C::g;
-  (c.*ptr)(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+  (c.*ptr)(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+#endif
+
   (c.*ptr)(10, version);
  
-  C::h(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+  C::h(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+#endif
+
   C::h(10, version);
 
   void (*static_ptr)(int, ...) = &C::h; 
-  static_ptr(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+  static_ptr(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+#endif
+
   static_ptr(10, version);
 }
 
 int (^block)(int, ...);
 
 void t3()
 {
   C c(10);
   
-  block(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic block; call will abort at runtime}}
+  block(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic block; call will abort at runtime}}
+#endif
+
   block(10, version);
 }
 
 class D {
 public:
   void operator() (int a, ...);
 };
 
 void t4()
 {
   C c(10);
 
   D d;
   
-  d(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+  d(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+#endif
+
   d(10, version);
 }
 
 class E {
   E(int, ...); // expected-note 2{{implicitly declared private here}}
 };
 
 void t5()
 {
   C c(10);
   
-  E e(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime}} \
-    // expected-error{{calling a private constructor of class 'E'}}
-  (void)E(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime}} \
-    // expected-error{{calling a private constructor of class 'E'}}
+  E e(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime}}
+#endif
+  // expected-error@-4 {{calling a private constructor of class 'E'}}
+  (void)E(10, c);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic constructor; call will abort at runtime}}
+#endif
+  // expected-error@-4 {{calling a private constructor of class 'E'}}
 
 }
 
 // PR5761: unevaluated operands and the non-POD warning
 class Foo {
  public:
   Foo() {}
 };
 
 int Helper(...);
 const int size = sizeof(Helper(Foo()));
 
 namespace std {
   class type_info { };
 }
 
 struct Base { virtual ~Base(); };
 Base &get_base(...);
 int eat_base(...);
 
 void test_typeid(Base &base) {
-  (void)typeid(get_base(base)); // expected-warning{{cannot pass object of non-POD type 'Base' through variadic function; call will abort at runtime}} expected-warning{{expression with side effects will be evaluated despite being used as an operand to 'typeid'}}
+  (void)typeid(get_base(base));
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'Base' through variadic function; call will abort at runtime}}
+#else
+  // expected-warning@-4 {{cannot pass object of non-trivial type 'Base' through variadic function; call will abort at runtime}}
+#endif
+  // expected-warning@-6 {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}}
   (void)typeid(eat_base(base)); // okay
 }
 
 
 // rdar://7985267 - Shouldn't warn, doesn't actually use __builtin_va_start is
 // magic.
 
 void t6(Foo somearg, ... ) {
void t8(int n, ...) {
   __builtin_va_list list;
   __builtin_va_start(list, n);
   (void)__builtin_va_arg(list, Abstract); // expected-error{{second argument to 'va_arg' is of abstract type 'Abstract'}}
   __builtin_va_end(list);
 }
 
 int t9(int n) {
   // Make sure the error works in potentially-evaluated sizeof
-  return (int)sizeof(*(Helper(Foo()), (int (*)[n])0)); // expected-warning{{cannot pass object of non-POD type}}
+  return (int)sizeof(*(Helper(Foo()), (int (*)[n])0));
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{cannot pass object of non-POD type 'Foo' through variadic function; call will abort at runtime}}
+#endif
 }
 
 // PR14057
 namespace t10 {
   struct F {
     F();
   };
 
namespace t11 {
 
   function_ptr arr_f_ptr[5];
   member_ptr arr_m_ptr[5];
   block_ptr arr_b_ptr[5];
 
   void test() {
     C c(10);
 
-    (get_f_ptr())(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+    (get_f_ptr())(10, c);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+#endif
     (get_f_ptr())(10, version);
 
-    (c.*get_m_ptr())(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+    (c.*get_m_ptr())(10, c);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+#endif
     (c.*get_m_ptr())(10, version);
 
-    (get_b_ptr())(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic block; call will abort at runtime}}
+    (get_b_ptr())(10, c);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic block; call will abort at runtime}}
+#endif
+
     (get_b_ptr())(10, version);
 
-    (arr_f_ptr[3])(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+    (arr_f_ptr[3])(10, c);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic function; call will abort at runtime}}
+#endif
+
     (arr_f_ptr[3])(10, version);
 
-    (c.*arr_m_ptr[3])(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+    (c.*arr_m_ptr[3])(10, c);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+#endif
+
     (c.*arr_m_ptr[3])(10, version);
 
-    (arr_b_ptr[3])(10, c); // expected-warning{{cannot pass object of non-POD type 'C' through variadic block; call will abort at runtime}}
+    (arr_b_ptr[3])(10, c);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{cannot pass object of non-POD type 'C' through variadic block; call will abort at runtime}}
+#endif
     (arr_b_ptr[3])(10, version);
   }
 }

cfe/trunk/test/SemaTemplate/class-template-spec.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
 template<typename T, typename U = int> struct A; // expected-note {{template is declared here}} \
                                                  // expected-note{{explicitly specialized}}
 
 template<> struct A<double, double>; // expected-note{{forward declaration}}
 
 template<> struct A<float, float> {  // expected-note{{previous definition}}
   int x;
 };

 }
 
 // Diagnose specialization errors
 struct A<double> { }; // expected-error{{template specialization requires 'template<>'}}
 
 template<> struct ::A<double>;
 
 namespace N {
-  template<typename T> struct B; // expected-note 2{{explicitly specialized}}
+  template<typename T> struct B; // expected-note {{explicitly specialized}}
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{explicitly specialized}}
+#endif
 
   template<> struct ::N::B<char>; // okay
   template<> struct ::N::B<short>; // okay
   template<> struct ::N::B<int>; // okay
 
   int f(int);
 }
 
 template<> struct N::B<int> { }; // okay
 
-template<> struct N::B<float> { }; // expected-warning{{C++11 extension}}
+template<> struct N::B<float> { };
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{first declaration of class template specialization of 'B' outside namespace 'N' is a C++11 extension}}
+#endif
+
 
 namespace M {
   template<> struct ::N::B<short> { }; // expected-error{{class template specialization of 'B' not in a namespace enclosing 'N'}}
 
   template<> struct ::A<long double>; // expected-error{{must occur at global scope}}
 }
 
 template<> struct N::B<char> { 
namespace PR18009 {
 
   template<int A> struct outer {
     template<int B, int C> struct inner {};
     template<int C> struct inner<A * 2, C> {};
   };
 }
 
 namespace PR16519 {
-  template<typename T, T...N> struct integer_sequence { typedef T value_type; }; // expected-warning {{extension}}
+  template<typename T, T...N> struct integer_sequence { typedef T value_type; };
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{variadic templates are a C++11 extension}}
+#endif
 
   template<typename T> struct __make_integer_sequence;
-  template<typename T, T N> using make_integer_sequence = typename __make_integer_sequence<T>::template make<N, N % 2>::type; // expected-warning {{extension}}
-
-  template<typename T, typename T::value_type ...Extra> struct __make_integer_sequence_impl; // expected-warning {{extension}}
-  template<typename T, T ...N, T ...Extra> struct __make_integer_sequence_impl<integer_sequence<T, N...>, Extra...> { // expected-warning 2{{extension}}
+  template<typename T, T N> using make_integer_sequence = typename __make_integer_sequence<T>::template make<N, N % 2>::type;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{alias declarations are a C++11 extension}}
+#endif
+
+  template<typename T, typename T::value_type ...Extra> struct __make_integer_sequence_impl;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{variadic templates are a C++11 extension}}
+#endif
+
+  template<typename T, T ...N, T ...Extra> struct __make_integer_sequence_impl<integer_sequence<T, N...>, Extra...> {
+#if __cplusplus <= 199711L
+  // expected-warning@-2 2 {{variadic templates are a C++11 extension}}
+#endif
     typedef integer_sequence<T, N..., sizeof...(N) + N..., Extra...> type;
   };
 
   template<typename T> struct __make_integer_sequence {
     template<T N, T Parity, typename = void> struct make;
     template<typename Dummy> struct make<0, 0, Dummy> { typedef integer_sequence<T> type; };
     template<typename Dummy> struct make<1, 1, Dummy> { typedef integer_sequence<T, 0> type; };
     template<T N, typename Dummy> struct make<N, 0, Dummy> : __make_integer_sequence_impl<make_integer_sequence<T, N/2> > {};
     template<T N, typename Dummy> struct make<N, 1, Dummy> : __make_integer_sequence_impl<make_integer_sequence<T, N/2>, N - 1> {};
   };
 
-  using X = make_integer_sequence<int, 5>; // expected-warning {{extension}}
-  using X = integer_sequence<int, 0, 1, 2, 3, 4>; // expected-warning {{extension}}
+  using X = make_integer_sequence<int, 5>;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{alias declarations are a C++11 extension}}
+#endif
+
+  using X = integer_sequence<int, 0, 1, 2, 3, 4>;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{alias declarations are a C++11 extension}}
+#endif
 }
 
 namespace DefaultArgVsPartialSpec {
   // Check that the diagnostic points at the partial specialization, not just at
   // the default argument.
   template<typename T, int N =
       sizeof(T) // expected-note {{template parameter is used in default argument declared here}}
   > struct X {};
   template<typename T> struct X<T> {}; // expected-error {{non-type template argument depends on a template parameter of the partial specialization}}
 
   template<typename T,
       T N = 0 // expected-note {{template parameter is declared here}}
   > struct S;
   template<typename T> struct S<T> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'T'}}
 }

cfe/trunk/test/SemaTemplate/instantiate-cast.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 { int x; }; // expected-note 2 {{candidate constructor}}
+struct A { int x; };
+// expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'int' to 'const A' for 1st argument}}
+#if __cplusplus >= 201103L
+// expected-note@-3 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'int' to 'A' for 1st argument}}
+#endif
+// expected-note@-5 {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
 
 class Base { 
 public:
   virtual void f();
 };
 
 class Derived : public Base { };
 

cfe/trunk/test/SemaTemplate/instantiate-expr-4.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++ Functional Casts
 // ---------------------------------------------------------------------
 template<int N>
 struct ValueInit0 {
   int f() {
     return int();
   }
 };
 
 template struct ValueInit0<5>;
 
 template<int N>
 struct FunctionalCast0 {
   int f() {
     return int(N);
   }
 };
 
 template struct FunctionalCast0<5>;
 
 struct X { // expected-note 3 {{candidate constructor (the implicit copy constructor)}}
+#if __cplusplus >= 201103L
+// expected-note@-2 3 {{candidate constructor (the implicit move constructor) not viable}}
+#endif
   X(int, int); // expected-note 3 {{candidate constructor}}
 };
 
 template<int N, int M>
 struct BuildTemporary0 {
   X f() {
     return X(N, M);
   }

 
 // ---------------------------------------------------------------------
 // initializer lists
 // ---------------------------------------------------------------------
 template<typename T, typename Val1>
 struct InitList1 {
   void f(Val1 val1) { 
     T x = { val1 };
+#if __cplusplus >= 201103L
+    // expected-error@-2 {{type 'float' cannot be narrowed to 'int' in initializer list}}
+    // expected-note@-3 {{insert an explicit cast to silence this issue}}
+#endif
   }
 };
 
 struct APair {
   int *x;
   const float *y;
 };
 
 template struct InitList1<int[1], float>;
+#if __cplusplus >= 201103L
+// expected-note@-2 {{instantiation of member function}}
+#endif
 template struct InitList1<APair, int*>;
 
 template<typename T, typename Val1, typename Val2>
 struct InitList2 {
   void f(Val1 val1, Val2 val2) { 
     T x = { val1, val2 }; // expected-error{{cannot initialize}}
   }
 };

cfe/trunk/test/SemaTemplate/instantiate-member-class.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 PR8965 {
   template<typename T>
   struct X {
     typedef int type;
 
     T field; // expected-note{{in instantiation of member class}}
   };
template <typename T> class C<T>::Foo {
     int x;
   };
   template class C<int>;
 }
 
 namespace AliasTagDef {
   template<typename T>
   struct F {
-    using S = struct U { // expected-warning {{C++11}}
+    using S = struct U {
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{alias declarations are a C++11 extension}}
+#endif
       T g() {
         return T();
       }
     };
   };
 
   int m = F<int>::S().g();
   int n = F<int>::U().g();
 }
 
 namespace rdar10397846 {
   template<int I> struct A
   {
     struct B
     {
-      struct C { C() { int *ptr = I; } }; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}} \
-                                             expected-warning{{expression which evaluates to zero treated as a null pointer constant of type 'int *'}}
+      struct C { C() { int *ptr = I; } };
+#if __cplusplus >= 201103L
+      // expected-error@-2 {{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
+#else
+      // expected-warning@-4 {{expression which evaluates to zero treated as a null pointer constant of type 'int *'}}
+#endif
+      // expected-error@-6 {{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
     };
   };
 
   template<int N> void foo()
   {
     class A<N>::B::C X; // expected-note 2 {{in instantiation of member function}}
     int A<N+1>::B::C::*member = 0;
   }
 
   void bar()
   {
     foo<0>(); // expected-note{{in instantiation of function template}}
     foo<1>(); // expected-note{{in instantiation of function template}}
   }
 }