Lit C++11 Compatibility Patch #8

[tigerleapgorge]

Summary

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

CXX/basic/basic.lookup/basic.lookup.classref/p1.cpp

Ambiguous class member lookup has been fixed in C++11
http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1111
Restrict the following diagnostics to C++98.
  C++98: warning: lookup of 'set' in member access expression is ambiguous; using member of 'Value'
         note: lookup in the object type 'Value' refers here
         note: lookup from the current scope refers here

CXX/class/class.friend/p1.cpp

Restrict the following diagnostics to C++98.
  C++98 error: friends cannot be members of the declaring class

CXX/class/class.friend/p2.cpp

Restrict the following 2 diagnostics to C++98.
  C++98: warning: non-class friend type 'int' is a C++11 extension
  C++98: warning: unelaborated friend declaration is a C++11 extension; specify 'struct' to befriend 'B0'

CXX/stmt.stmt/stmt.dcl/p3.cpp

Definition of POD has been relaxed in C++11 such that a struct with 
a trivial copy assignment operator is still considered POD.

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2294.html
In the above paper, the following clause has been crossed out.
  “and has no user-declared copy assignment operator and no user-declared destructor” 

For this test, struct Z is still a POD struct in C++11.
Therefore goto can jump over Z’s instantiation without causing a compiler Error.
Restrict the following to C++98
  C++98: error: cannot jump from this goto statement to its label
  C++98: note: jump bypasses initialization of non-POD variable

CXX/temp/temp.arg/temp.arg.nontype/p1.cpp

C++11 accepts arbitrary literal types for non-type template parameters
  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3413.html

Change in diagnostics.
  C++98: error: non-type template argument for template parameter of pointer type 'int *' must have its address taken
  C++11: error: non-type template argument of type 'int' is not a constant expression
         note: read of non-const variable 'i' is not allowed in a constant expression
         note: declared here

Restrict the following to C++98
  C++98: warning: non-type template argument referring to object 'ki' with internal linkage is a C++11 extension
         Note: non-type template argument refers to object here

Change in diagnostics.
  C++98: error: non-type template argument refers to thread-local object
         note: non-type template argument refers here
  C++11: error: non-type template argument of type 'int *' is not a constant expression
         note: template parameter is declared here

Restrict the following to C++98
  C++98: non-type template argument referring to function 'f_internal' with internal linkage is a C++11 extension
         note: non-type template argument refers to function here

Change in diagnostics
  C++98: error: non-type template argument refers to object 'n' that does not have linkage
         note: non-type template argument refers to object here
  C++11: error: non-type template argument of type 'int *' is not a constant expression
         note: pointer to 'n' is not a constant expression
         note: declared here
         note: template parameter is declared here

Change in diagnostics 
  C++98: error: non-type template argument for template parameter of pointer type 'int *' must have its address taken
  C++11: error: non-type template argument of type 'int *' is not a constant expression
         note: read of non-constexpr variable 'iptr' is not allowed in a constant expression
         note: declared here

CXX/temp/temp.arg/temp.arg.type/p2.cpp

Unnamed types can now be used as template arguments in C++11
http://stackoverflow.com/questions/5131691/what-is-an-unnamed-type-in-c
Restrict the following diagnostics to C++98.
  C++98: Warning: template argument uses unnamed type

CXX/temp/temp.fct.spec/temp.deduct/p9.cpp

Template argument constant expression narrowing is not allowed.
  http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1809
Restrict the following diagnostics to C++98.
  C++98:  error: call to 'f' is ambiguous
          note: candidate function
          note: candidate function

CXX/temp/temp.spec/no-body.cpp

Explicit instantiation of a template inside a nested namespace is an Error in C++11.
This could be the result of the following defect fix.
  http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#995

Added 3 instances of the following diagnostics.
  C++11: error: explicit instantiation of 'x' must occur at global scope
         note: explicit instantiation refers here

Also remove these 3 explicit instantiations from the -fixit runs.

CodeGenCXX/const-init.cpp

Use constexpr instead of const in C++11 so the compiler does not complain.
  C++98: static const double d = 1.0;
  C++11: static constexpr double d = 1.0;

Parser/cxx-class.cpp

Change in diagnostics for malformed class member definitions without parenthesis.

In C++11, this looks like malformed initializer lists.

  C++98: error: function definition does not declare parameters
  C++11: error: expected expression
         error: expected '}'
         note: to match this '{'
         error: expected ';' after class
         error: extraneous closing brace

  C++98: error: function definition does not declare parameters
  C++11: error: variable has incomplete type 'void'
         error: expected ';' after top level declarator

Restrict 6 instances of the following to C++98
  C++98: in-class initialization of non-static data member is a C++11 extension

Parser/cxx-decl.cpp

Restrict 1 instance of the following to C++98
  C++98: error: commas at the end of enumerator lists are a C++11 extension

Restrict 2 instances of the following to C++98
  C++98: error: rvalue references are a C++11 extension

Change in diagnostics as a result of attribute list in C++11
  C++98: error: expected expression
         error: expected unqualified-id
  C++11: error: an attribute list cannot appear here

Restrict 1 instance of the following to C++98
  C++98: error: alias declarations are a C++11 extension

Restrict 1 instance of the following to C++98
  C++98: error: 'template' keyword outside of a template

Add 1 instance of the following to C++11
  C++11: error: 'friend' must appear first in a non-function declaration

Change in diagnostics for unmatched braces at end of file.
  C++98: error: expected ';' after top level declarator
  C++11: error: expected expression
         error: expected '}'
         note: to match this '{'
         error: expected ';' after top level declarator

Parser/cxx-friend.cpp

C++11 allows unelaborated friend declarations and non-class friend types.
Restrict the following diagnostics to C++98.
  C++98: warning: unelaborated friend declaration is a C++11 extension; specify 'class' to befriend 'C'
  C++98: warning: unelaborated friend declaration is a C++11 extension; specify 'union' to befriend 'U'
  C++98: warning: non-class friend type 'int' is a C++11 extension

SemaCXX/anonymous-struct.cpp

In C++11, struct member ‘x’ of type S is still POD since there is nothing in the constructor.
  http://www.stroustrup.com/C++11FAQ.html#PODs
Restrict the following diagnostics to C++98.
  C++98: error: anonymous struct member 'x' has a non-trivial constructor
         note: because type 'S' has a user-provided default constructor

C++11 allows unnamed types for template arguments
Restrict the following diagnostics to C++98.
  C++98: warning: template argument uses unnamed type
         note: unnamed type used in template argument was declared here

SemaCXX/class.cpp

Change in diagnostics regarding ‘auto’
  C++98: warning: 'auto' storage class specifier is redundant
  C++11: warning: 'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases

Restrict the following diagnostics to C++98.
  C++98: warning: in-class initialization of non-static data member is a C++11 extension

Add the following diagnostics to C++11.
  C++11: error: static const volatile data member must be initialized out of line

For the last part, slightly modify the test by changing const to constexpr for C++11
  in C++98 we still test for
    static const float x = 5.0f;
    static const float y = foo();

  in C++11 we test for
    static constexpr float x = 5.0f;
    static constexpr float y = foo();
    
  for the above C++11 case
    Assigning 5.0f to x no longer issues any diagnostics.
    Assigning foo’s return to y generates the following diagnostics.
      C++11: error: constexpr variable 'y' must be initialized by a constant expression
             error: constexpr variable 'y' must be initialized by a constant expression
             note: declared here

SemaCXX/conversion-function.cpp

Diagnostic wordings changed from C++98 to C++11
 2 Changes in diagnostics between C++98 and C++11
    C++98: warning: C++98 requires an accessible copy constructor for class 'A1' 
           when binding a reference to a temporary; was private [-Wbind-to-temporary-copy]
    C++11: warning: copying parameter of type 'A1' when binding a reference to a 
           temporary would invoke an inaccessible constructor in C++98 [-Wc++98-compat-bind-to-temporary-copy]

    C++98: error: cannot specify any part of a return type in the declaration of a conversion function
    C++11: error: cannot specify any part of a return type in the declaration of a conversion function; 
                  use an alias template to declare a conversion to 'T (&)()'

 1 extra note diagnostics for move candidate constructor.
   C++11: note: candidate constructor (the implicit move constructor) not viable: 
                 no known conversion from 'smart_ptr::Y' to 'smart_ptr::X &&' for 1st argument

  1 Change in diagnostics wording non-POD became non-trivial
   C++98: error: cannot pass object of non-POD type 'Other' through variadic constructor; call will abort at runtim
    C++11: error: cannot pass object of non-trivial type 'Other' through variadic constructor; call will abort at runtim

SemaCXX/cxx1y-variable-templates_in_class.cpp
SemaCXX/cxx1y-variable-templates_top_level.cpp

These 2 tests check for variable template support in 3 dialects:
 C++98, C++11 and C++14
Since the first run line of each test specifically test for pre C++11 behavior, 
simply add –std=c++98 to the first RUN line.

SemaCXX/exceptions.cpp

C++11 no longer issues an error regarding pointer to incomplete type inside throw().
This appears valid since dynamic exception specifications aka throw() has been deprecated.
And that “parameter packs are allowed in C++11.”
  http://en.cppreference.com/w/cpp/language/except_spec
Restrict the following group of 3 diagnostics to C++98
  C++98: error: pointer to incomplete type 'Decay::E' is not allowed in exception specification
         note: in instantiation of template class 'Decay::C<Decay::E [10]>' requested here
         note: forward declaration of 'Decay::E'

Also, restrict the rvalue reference diagnostics to C++98.
  C++98: warning: rvalue references are a C++11 extension

SemaCXX/qual-id-test.cpp

Ambiguous class member lookup has been fixed in C++11
Restrict the following diagnostics to C++98.
  C++98: error: lookup of 'base' in member access expression is ambiguous
         note: lookup in the object type 'A::sub' refers here
         note: lookup from the current scope refers here

SemaCXX/unused.cpp

In C++11, volatile-qualified lvalue undergoes lvalue-to-rvalue conversion inside discared-value expressions.
The statement *x; is a discared-value expression of a lvalue of an indirection.
Therefore *x; considered a use of x in C++11.
http://open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1054
http://stackoverflow.com/questions/20242868/correct-behaviour-of-trivial-statements-involving-expressions-with-volatile-vari

Restrict the following diagnostics to C++98.
  C++98: warning: expression result unused; assign into a variable to force a volatile load

SemaCXX/warn-unused-value.cpp

Simular to previous test case, volatile in a discared-value expression is now a use in C++11
Restrict the following diagnostics to C++98.
  C++98: warning: expression result unused; assign into a variable to force a volatile load

SemaTemplate/member-access-expr.cpp

Ambiguous class member lookup has been fixed in C++11
  http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1111
Restrict the following diagnostics to C++98.
  C++98: error: lookup of 'CrazyBase' in member access expression is ambiguous
         note: lookup in the object type 'X1' refers here
         note: lookup from the current scope refers here

SemaTemplate/recovery-crash.cpp

C++11 allows the use of local types as template arguments.
Restrict the following diagnostics to C++98.
  C++98: warning: template argument uses local type 'LocalStruct'
         note: in instantiation of function template specialization

SemaTemplate/temp_arg_type.cpp

C++11 allows both local type and unnamed type to be used in template arguments.
Restrict the following diagnostics to C++98.
  C++98: warning: template argument uses local type 'X'
  C++98: warning: template argument uses unnamed type
         note: unnamed type used in template argument was declared here

[tigerleapgorge]

Committed to Trunk in r266387

CXX/basic/basic.lookup/basic.lookup.classref/p1.cpp

 // RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -verify -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -fdiagnostics-show-option -verify -std=c++11 %s
 
 // C++98 [basic.lookup.classref]p1:
 //   In a class member access expression (5.2.5), if the . or -> token is
 //   immediately followed by an identifier followed by a <, the identifier must
 //   be looked up to determine whether the < is the beginning of a template
 //   argument list (14.2) or a less-than operator. The identifier is first
 //   looked up in the class of the object expression. If the identifier is not
 //   found, it is then looked up in the context of the entire postfix-expression
 //   and shall name a class or function template. If the lookup in the class of
 //   the object expression finds a template, the name is also looked up in the
 //   context of the entire postfix-expression and
 //    -- if the name is not found, the name found in the class of the object
 //       expression is used, otherwise
 //    -- if the name is found in the context of the entire postfix-expression
 //       and does not name a class template, the name found in the class of the
 //       object expression is used, otherwise
 //    -- if the name found is a class template, it must refer to the same
 //       entity as the one found in the class of the object expression,
 //       otherwise the program is ill-formed.
 
 // From PR 7247
 template<typename T>
-struct set{};  // expected-note{{lookup from the current scope refers here}}
+struct set{};
+#if __cplusplus <= 199711L
+// expected-note@-2 {{lookup from the current scope refers here}}
+#endif
 struct Value {
   template<typename T>
-  void set(T value) {}  // expected-note{{lookup in the object type 'Value' refers here}}
+  void set(T value) {}
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{lookup in the object type 'Value' refers here}}
+#endif
 
   void resolves_to_same() {
     Value v;
     v.set<double>(3.2);
   }
 };
 void resolves_to_different() {
   {
     Value v;
     // The fact that the next line is a warning rather than an error is an
     // extension.
-    v.set<double>(3.2);  // expected-warning{{lookup of 'set' in member access expression is ambiguous; using member of 'Value'}}
+    v.set<double>(3.2);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{lookup of 'set' in member access expression is ambiguous; using member of 'Value'}}
+#endif
   }
   {
     int set;  // Non-template.
     Value v;
     v.set<double>(3.2);
   }
 }
 

CXX/class/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
 
 struct Outer {
   struct Inner {
     int intfield;
   };
 };
 
 struct Base {
class A {
 
   friend void global_function();
   friend void global_c_function();
 
   friend class UndeclaredSoFar;
   UndeclaredSoFar x; // expected-error {{unknown type name 'UndeclaredSoFar'}}
 
   void a_member();
-  friend void A::a_member(); // expected-error {{friends cannot be members of the declaring class}}
+  friend void A::a_member();
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{friends cannot be members of the declaring class}}
+#endif
   friend void a_member(); // okay (because we ignore class scopes when looking up friends)
   friend class A::AInner; // this is okay as an extension
   friend class AInner; // okay, refers to ::AInner
 
   friend void Derived::missing_member(); // expected-error {{no function named 'missing_member' with type 'void ()' was found in the specified scope}}
 
   friend void Derived::base_member(); // expected-error {{no function named 'base_member' with type 'void ()' was found in the specified scope}}
 

CXX/class/class.friend/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
 
 struct B0;
 
 class A {
   friend class B {}; // expected-error {{cannot define a type in a friend declaration}}
-  friend int; // expected-warning {{non-class friend type 'int' is a C++11 extension}}
-  friend B0; // expected-warning {{specify 'struct' to befriend 'B0'}}
+  friend int;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{non-class friend type 'int' is a C++11 extension}}
+#endif
+  friend B0;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{unelaborated friend declaration is a C++11 extension; specify 'struct' to befriend 'B0'}}
+#endif
   friend class C; // okay
 };

CXX/stmt.stmt/stmt.dcl/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
 
 // PR10034
 struct X {};
 
 void exx(X) {}
 
 int test_ptr10034(int argc, char **argv)
 {
end:
   return;
 }
 
 struct Z {
   Z operator=(const Z&);
 };
 
 void test_Z() {
-  goto end; // expected-error{{cannot jump from this goto statement to its label}}
-  Z z; // expected-note{{jump bypasses initialization of non-POD variable}}
+  goto end;
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{cannot jump from this goto statement to its label}}
+#endif
+
+  Z z;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{jump bypasses initialization of non-POD variable}}
+#endif
+
  end:
   return;
 }

CXX/temp/temp.arg/temp.arg.nontype/p1.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu %s
+// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu -std=c++11 %s
 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -triple=x86_64-linux-gnu %s -DCPP11ONLY
 
 // C++11 [temp.arg.nontype]p1:
 //
 //   A template-argument for a non-type, non-template template-parameter shall
 //   be one of:
 //   -- an integral constant expression; or
 //   -- the name of a non-type template-parameter ; or

 //      static storage duration and external or internal linkage or a function
 //      with external or internal linkage, including function templates and
 //      function template-ids, but excluting non-static class members, expressed
 //      (ignoring parentheses) as & id-expression, except that the & may be
 //      omitted if the name refers to a function or array and shall be omitted
 //      if the corresopnding template-parameter is a reference; or
 namespace addr_of_obj_or_func {
   template <int* p> struct X0 { }; // expected-note 5{{here}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 2{{template parameter is declared here}}
+#endif
+
   template <int (*fp)(int)> struct X1 { };
   template <int &p> struct X2 { }; // expected-note 4{{here}}
   template <const int &p> struct X2k { }; // expected-note {{here}}
   template <int (&fp)(int)> struct X3 { }; // expected-note 4{{here}}
 
   int i = 42;
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
+
   int iarr[10];
   int f(int i);
-  const int ki = 9; // expected-note 5{{here}}
-  __thread int ti = 100; // expected-note 2{{here}}
-  static int f_internal(int); // expected-note 4{{here}}
+  const int ki = 9;
+#if __cplusplus <= 199711L
+  // expected-note@-2 5{{non-type template argument refers to object here}}
+#endif
+
+  __thread int ti = 100; // expected-note {{here}}
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{here}}
+#endif
+
+  static int f_internal(int);
+#if __cplusplus <= 199711L
+  // expected-note@-2 4{{non-type template argument refers to function here}}
+#endif
+
   template <typename T> T f_tmpl(T t);
   struct S { union { int NonStaticMember; }; };
 
   void test() {
-    X0<i> x0a; // expected-error {{must have its address taken}}
+    X0<i> x0a;
+#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 'i' is not allowed in a constant expression}}
+#endif
     X0<&i> x0a_addr;
     X0<iarr> x0b;
     X0<&iarr> x0b_addr; // expected-error {{cannot be converted to a value of type 'int *'}}
-    X0<ki> x0c; // expected-error {{must have its address taken}} expected-warning {{internal linkage is a C++11 extension}}
-    X0<&ki> x0c_addr; // expected-error {{cannot be converted to a value of type 'int *'}} expected-warning {{internal linkage is a C++11 extension}}
-    X0<&ti> x0d_addr; // expected-error {{refers to thread-local object}}
+    X0<ki> x0c; // expected-error {{must have its address taken}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
+    X0<&ki> x0c_addr; // expected-error {{cannot be converted to a value of type 'int *'}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
+    X0<&ti> x0d_addr;
+#if __cplusplus <= 199711L
+    // expected-error@-2 {{non-type template argument refers to thread-local object}}
+#else
+    // expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
+#endif
+
     X1<f> x1a;
     X1<&f> x1a_addr;
     X1<f_tmpl> x1b;
     X1<&f_tmpl> x1b_addr;
     X1<f_tmpl<int> > x1c;
     X1<&f_tmpl<int> > x1c_addr;
-    X1<f_internal> x1d; // expected-warning {{internal linkage is a C++11 extension}}
-    X1<&f_internal> x1d_addr; // expected-warning {{internal linkage is a C++11 extension}}
+    X1<f_internal> x1d;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
+    X1<&f_internal> x1d_addr;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
     X2<i> x2a;
     X2<&i> x2a_addr; // expected-error {{address taken}}
     X2<iarr> x2b; // expected-error {{cannot bind to template argument of type 'int [10]'}}
     X2<&iarr> x2b_addr; // expected-error {{address taken}}
-    X2<ki> x2c; // expected-error {{ignores qualifiers}} expected-warning {{internal linkage is a C++11 extension}}
-    X2k<ki> x2kc; // expected-warning {{internal linkage is a C++11 extension}}
-    X2k<&ki> x2kc_addr; // expected-error {{address taken}} expected-warning {{internal linkage is a C++11 extension}}
+    X2<ki> x2c; // expected-error {{ignores qualifiers}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
+    X2k<ki> x2kc;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
+    X2k<&ki> x2kc_addr; // expected-error {{address taken}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
     X2<ti> x2d_addr; // expected-error {{refers to thread-local object}}
     X3<f> x3a;
     X3<&f> x3a_addr; // expected-error {{address taken}}
     X3<f_tmpl> x3b;
     X3<&f_tmpl> x3b_addr; // expected-error {{address taken}}
     X3<f_tmpl<int> > x3c;
     X3<&f_tmpl<int> > x3c_addr; // expected-error {{address taken}}
-    X3<f_internal> x3d; // expected-warning {{internal linkage is a C++11 extension}}
-    X3<&f_internal> x3d_addr; // expected-error {{address taken}} expected-warning {{internal linkage is a C++11 extension}}
+    X3<f_internal> x3d;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
+    X3<&f_internal> x3d_addr; // expected-error {{address taken}}
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{internal linkage is a C++11 extension}}
+#endif
+
+    int n;
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{non-type template argument refers to object here}}
+#else
+    // expected-note@-4 {{declared here}}
+#endif
+
+    X0<&n> x0_no_linkage;
+#if __cplusplus <= 199711L
+    // expected-error@-2 {{non-type template argument refers to object 'n' that does not have linkage}}
+#else
+    // expected-error@-4 {{non-type template argument of type 'int *' is not a constant expression}}
+    // expected-note@-5 {{pointer to 'n' is not a constant expression}}
+#endif
 
-    int n; // expected-note {{here}}
-    X0<&n> x0_no_linkage; // expected-error {{non-type template argument refers to object 'n' that does not have linkage}}
     struct Local { static int f() {} }; // expected-note {{here}}
     X1<&Local::f> x1_no_linkage; // expected-error {{non-type template argument refers to function 'f' that does not have linkage}}
     X0<&S::NonStaticMember> x0_non_static; // expected-error {{non-static data member}}
   }
 }
 
 //   -- a constant expression that evaluates to a null pointer value (4.10); or
 //   -- a constant expression that evaluates to a null member pointer value
 //      (4.11); or
 //   -- a pointer to member expressed as described in 5.3.1.
 
 namespace bad_args {
   template <int* N> struct X0 { }; // expected-note 2{{template parameter is declared here}}
   int i = 42;
   X0<&i + 2> x0a; // expected-error{{non-type template argument does not refer to any declaration}}
   int* iptr = &i;
-  X0<iptr> x0b; // expected-error{{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
+
+  X0<iptr> x0b;
+#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 'iptr' is not allowed in a constant expression}}
+#endif
 }
 #endif // CPP11ONLY
 
 namespace default_args {
 #ifdef CPP11ONLY
 namespace lambdas {
 template<int I = ([] { return 5; }())> //expected-error 2{{constant expression}} expected-note{{constant expression}}
 int f();
 }
 #endif // CPP11ONLY
 
-}
+}
 

CXX/temp/temp.arg/temp.arg.type/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
+
 template<class T> struct A {
   static T t; // expected-error{{static data member instantiated with function type 'int ()'}}
 };
 typedef int function();
 A<function> a; // expected-note{{instantiation of}}
 
 template<typename T> struct B {
   B() { T t; } // expected-error{{variable instantiated with function type 'int ()'}}
 };
 B<function> b; // expected-note{{instantiation of}}
 
 template <typename T> int f0(void *, const T&); // expected-note{{candidate template ignored: substitution failure}}
-enum {e}; // expected-note{{unnamed type used in template argument was declared here}}
+enum {e};
+#if __cplusplus <= 199711L
+// expected-note@-2 {{unnamed type used in template argument was declared here}}
+#endif
 
 void test_f0(int n) {
-  int i = f0(0, e); // expected-warning{{template argument uses unnamed type}}
+  int i = f0(0, e);
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{template argument uses unnamed type}}
+#endif
+
   int vla[n];
   f0(0, vla); // expected-error{{no matching function for call to 'f0'}}
 }
 
 namespace N0 {
   template <typename R, typename A1> void f0(R (*)(A1));
   template <typename T> int f1(T);
   template <typename T, typename U> int f1(T, U);
-  enum {e1}; // expected-note 2{{unnamed type used in template argument was declared here}}
-  enum {e2}; // expected-note 2{{unnamed type used in template argument was declared here}}
-  enum {e3}; // expected-note{{unnamed type used in template argument was declared here}}
+  enum {e1};
+#if __cplusplus <= 199711L
+  // expected-note@-2 2{{unnamed type used in template argument was declared here}}
+#endif
+
+  enum {e2};
+#if __cplusplus <= 199711L
+  // expected-note@-2 2{{unnamed type used in template argument was declared here}}
+#endif
+
+  enum {e3};
+#if __cplusplus <= 199711L
+ // expected-note@-2 {{unnamed type used in template argument was declared here}}
+#endif
 
   template<typename T> struct X;
   template<typename T> struct X<T*> { };
 
   void f() {
-    f0( // expected-warning{{template argument uses unnamed type}}
-       &f1<__typeof__(e1)>); // expected-warning{{template argument uses unnamed type}}
-    int (*fp1)(int, __typeof__(e2)) = f1; // expected-warning{{template argument uses unnamed type}}
-    f1(e2); // expected-warning{{template argument uses unnamed type}}
+    f0(
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{template argument uses unnamed type}}
+#endif
+
+       &f1<__typeof__(e1)>);
+#if __cplusplus <= 199711L
+ // expected-warning@-2 {{template argument uses unnamed type}}
+#endif
+
+    int (*fp1)(int, __typeof__(e2)) = f1;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{template argument uses unnamed type}}
+#endif
+
+    f1(e2);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{template argument uses unnamed type}}
+#endif
+
     f1(e2);
 
-    X<__typeof__(e3)*> x; // expected-warning{{template argument uses unnamed type}}
+    X<__typeof__(e3)*> x;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{template argument uses unnamed type}}
+#endif
   }
 }

CXX/temp/temp.fct.spec/temp.deduct/p9.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 <int> int f(int);  // expected-note 2{{candidate}}
-template <signed char> int f(int); // expected-note 2{{candidate}}
-int i1 = f<1>(0); // expected-error{{ambiguous}}
-int i2 = f<1000>(0); // expected-error{{ambiguous}}
+template <int> int f(int);  // expected-note {{candidate function}}
+#if __cplusplus <= 199711L
+// expected-note@-2 {{candidate function}}
+#endif
+
+template <signed char> int f(int); // expected-note {{candidate function}}
+#if __cplusplus <= 199711L
+// expected-note@-2 {{candidate function}}
+#endif
+
+int i1 = f<1>(0); // expected-error{{call to 'f' is ambiguous}}
+int i2 = f<1000>(0);
+#if __cplusplus <= 199711L
+// expected-error@-2{{call to 'f' is ambiguous}}
+#endif
 
 namespace PR6707 {
   template<typename T, T Value>
   struct X { };
 
   template<typename T, T Value>
   void f(X<T, Value>);
 

CXX/temp/temp.spec/no-body.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
 // RUN: cp %s %t
 // RUN: not %clang_cc1 -x c++ -fixit %t -DFIXING
 // RUN: %clang_cc1 -x c++ %t -DFIXING
 
 template<typename T> void f(T) { }
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{explicit instantiation refers here}}
+#endif
+
 template<typename T> void g(T) { }
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{explicit instantiation refers here}}
+#endif
+
 template<typename T> struct x { };
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{explicit instantiation refers here}}
+#endif
+
 template<typename T> struct y { };  // expected-note {{declared here}}
 
-namespace good {
+namespace good { // Only good in C++98/03
+#ifndef FIXING
   template void f<int>(int);
+#if __cplusplus >= 201103L
+  // expected-error@-2 {{explicit instantiation of 'f' must occur at global scope}}
+#endif
+
   template void g(int);
+#if __cplusplus >= 201103L
+  // expected-error@-2 {{explicit instantiation of 'g' must occur at global scope}}
+#endif
+
   template struct x<int>;
+#if __cplusplus >= 201103L
+  // expected-error@-2 {{explicit instantiation of 'x' must occur at global scope}}
+#endif
+#endif
 }
 
 namespace unsupported {
 #ifndef FIXING
  template struct y;     // expected-error {{elaborated type refers to a template}}
 #endif
 }
 

CodeGenCXX/const-init.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -std=c++98 -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -std=c++11 -o - %s | FileCheck %s
 
 // CHECK: @a = global i32 10
 int a = 10;
 // CHECK: @ar = constant i32* @a
 int &ar = a;
 
 void f();
 // CHECK: @fr = constant void ()* @_Z1fv

 };
 
 // CHECK: @_ZN6PR55812g0E = global %"class.PR5581::C" { i32 1 }
 C g0 = { C::e1 };
 }
 
 namespace test2 {
   struct A {
+#if __cplusplus <= 199711L
     static const double d = 1.0;
     static const float f = d / 2;
+#else
+    static constexpr double d = 1.0;
+    static constexpr float f = d / 2;
+#endif
     static int g();
   } a;
 
   // CHECK: @_ZN5test22t0E = global double {{1\.0+e\+0+}}, align 8
   // CHECK: @_ZN5test22t1E = global [2 x double] [double {{1\.0+e\+0+}}, double {{5\.0+e-0*}}1], align 16
   // CHECK: @_ZN5test22t2E = global double* @_ZN5test21A1d
   // CHECK: @_ZN5test22t3E = global {{.*}} @_ZN5test21A1g
   double t0 = A::d;

Parser/cxx-class.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -fcxx-exceptions -std=c++11 %s
+
 class C;
 class C {
 public:
 protected:
   typedef int A,B;
   static int sf(), u;
 
   struct S {};

 // consume the token after the access specifier if it's a semicolon 
 // that was meant to be a colon
 class E {
 public; // expected-error{{expected ':'}}
   int i;
 };
 
 class F {
-    int F1 { return 1; } // expected-error{{function definition does not declare parameters}}
-    void F2 {} // expected-error{{function definition does not declare parameters}}
+    int F1 { return 1; }
+#if __cplusplus <= 199711L
+    // expected-error@-2 {{function definition does not declare parameters}}
+#else
+    // expected-error@-4 {{expected expression}}
+    // expected-error@-5 {{expected}}
+    // expected-note@-6 {{to match this '{'}}
+    // expected-error@-7 {{expected ';' after class}}
+#endif
+
+    void F2 {}
+#if __cplusplus <= 199711L
+    // expected-error@-2 {{function definition does not declare parameters}}
+#else
+    // expected-error@-4 {{variable has incomplete type 'void'}}
+    // expected-error@-5 {{expected ';' after top level declarator}}
+#endif
+
     typedef int F3() { return 0; } // expected-error{{function definition declared 'typedef'}}
     typedef void F4() {} // expected-error{{function definition declared 'typedef'}}
 };
+#if __cplusplus >= 201103L
+// expected-error@-2 {{extraneous closing brace}}
+#endif
 
 namespace ctor_error {
   class Foo {};
   // By [class.qual]p2, this is a constructor declaration.
   Foo::Foo (F) = F(); // expected-error{{does not match any declaration in 'ctor_error::Foo'}}
 
   class Ctor { // expected-note{{not complete until the closing '}'}}
     Ctor(f)(int); // ok
struct A {
     friend void f() = 123; // expected-error {{illegal initializer}}
     friend virtual void f(); // expected-error {{'virtual' is invalid in friend declarations}}
     friend void f() final; // expected-error {{'final' is invalid in friend declarations}}
     friend void f() override; // expected-error {{'override' is invalid in friend declarations}}
   };
 }
 
 class PR20760_a {
-  int a = ); // expected-warning {{extension}} expected-error {{expected expression}}
-  int b = }; // expected-warning {{extension}} expected-error {{expected expression}}
-  int c = ]; // expected-warning {{extension}} expected-error {{expected expression}}
+  int a = ); // expected-error {{expected expression}}
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
+
+  int b = }; // expected-error {{expected expression}}
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
+
+  int c = ]; // expected-error {{expected expression}}
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
+
 };
 class PR20760_b {
-  int d = d); // expected-warning {{extension}} expected-error {{expected ';'}}
-  int e = d]; // expected-warning {{extension}} expected-error {{expected ';'}}
-  int f = d // expected-warning {{extension}} expected-error {{expected ';'}}
+  int d = d); // expected-error {{expected ';'}}
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
+
+  int e = d]; // expected-error {{expected ';'}}
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
+
+  int f = d // expected-error {{expected ';'}}
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
+
 };
 
 namespace PR20887 {
 class X1 { a::operator=; }; // expected-error {{undeclared identifier 'a'}}
 class X2 { a::a; }; // expected-error {{undeclared identifier 'a'}}
 }
 
 class BadExceptionSpec {

Parser/cxx-decl.cpp

 // RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -pedantic-errors -fcxx-exceptions -fexceptions %s
+// RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -pedantic-errors -fcxx-exceptions -fexceptions -std=c++98 %s
+// RUN: %clang_cc1 -verify -fsyntax-only -triple i386-linux -pedantic-errors -fcxx-exceptions -fexceptions -std=c++11 %s
 
 const char const *x10; // expected-error {{duplicate 'const' declaration specifier}}
 
 int x(*g); // expected-error {{use of undeclared identifier 'g'}}
 
 struct Type {
   int Type;
 };
int bar() {
     return 1 ? P->x : P->y;
   }
 };
 
 class asm_class_test {
   void foo() __asm__("baz");
 };
 
-enum { fooenum = 1, }; // expected-error {{commas at the end of enumerator lists are a C++11 extension}}
+enum { fooenum = 1, };
+#if __cplusplus <= 199711L
+// expected-error@-2 {{commas at the end of enumerator lists are a C++11 extension}}
+#endif
 
 struct a {
   int Type : fooenum;
 };
 
 void test(struct Type *P) {
   int Type;
   Type = 1 ? P->Type : Type;
struct S {
     operator()();
   };
 
   int global1,
   __attribute__(()) global2,
   (global5),
   *global6,
   &global7 = global1,
-  &&global8 = static_cast<int&&>(global1), // expected-error 2{{rvalue reference}}
+  &&global8 = static_cast<int&&>(global1),
+#if __cplusplus <= 199711L
+  // expected-error@-2 2{{rvalue references are a C++11 extension}}
+#endif
+
   S::a,
   global9,
   global10 = 0,
   global11 == 0, // expected-error {{did you mean '='}}
   global12 __attribute__(()),
   global13(0),
   global14[2],
   global15;
void test (DIE die, DIE *Die, DIE INT, DIE *FLOAT) {
   FLOAT->foo();
 }
 
 namespace PR15017 {
   template<typename T = struct X { int i; }> struct S {}; // expected-error {{'PR15017::X' cannot be defined in a type specifier}}
 }
 
 // Ensure we produce at least some diagnostic for attributes in C++98.
-[[]] struct S; // expected-error 2{{}}
+[[]] struct S;
+#if __cplusplus <= 199711L
+// expected-error@-2 {{expected expression}}
+// expected-error@-3 {{expected unqualified-id}}
+#else
+// expected-error@-5 {{an attribute list cannot appear here}}
+#endif
 
 namespace test7 {
   struct Foo {
     void a();
     void b();
   };
 
   void Foo::
void test8() {
   // This used to crash.
   (&o)->(); // expected-error{{expected unqualified-id}}
 }
 
 namespace PR5066 {
   template<typename T> struct X {};
   X<int N> x; // expected-error {{type-id cannot have a name}}
 
-  using T = int (*T)(); // expected-error {{type-id cannot have a name}} expected-error {{C++11}}
+  using T = int (*T)(); // expected-error {{type-id cannot have a name}}
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{alias declarations are a C++11 extensio}}
+#endif
+
 }
 
 namespace PR17255 {
 void foo() {
-  typename A::template B<>; // expected-error {{use of undeclared identifier 'A'}} \
-                            // expected-error {{expected a qualified name after 'typename'}} \
-                            // expected-error {{'template' keyword outside of a template}}
+  typename A::template B<>; // expected-error {{use of undeclared identifier 'A'}}
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{'template' keyword outside of a template}}
+#endif
+  // expected-error@-4 {{expected a qualified name after 'typename'}}
 }
 }
 
 namespace PR17567 {
   struct Foobar { // expected-note 2{{declared here}}
     FooBar(); // expected-error {{missing return type for function 'FooBar'; did you mean the constructor name 'Foobar'?}}
     ~FooBar(); // expected-error {{expected the class name after '~' to name a destructor}}
   };
   FooBar::FooBar() {} // expected-error {{undeclared}} expected-error {{missing return type}}
   FooBar::~FooBar() {} // expected-error {{undeclared}} expected-error {{expected the class name}}
 }
 
 namespace DuplicateFriend {
   struct A {
     friend void friend f(); // expected-warning {{duplicate 'friend' declaration specifier}}
     friend struct B friend; // expected-warning {{duplicate 'friend' declaration specifier}}
+#if __cplusplus >= 201103L
+    // expected-error@-2 {{'friend' must appear first in a non-function declaration}}
+#endif
   };
 }
 
 // PR8380
 extern ""      // expected-error {{unknown linkage language}}
-test6a { ;// expected-error {{C++ requires a type specifier for all declarations}} \
-     // expected-error {{expected ';' after top level declarator}}
+test6a { ;// expected-error {{C++ requires a type specifier for all declarations}}
+#if __cplusplus <= 199711L
+// expected-error@-2 {{expected ';' after top level declarator}}
+#else
+// expected-error@-4 {{expected expression}}
+// expected-note@-5 {{to match this}}
+#endif
   
   int test6b;
+#if __cplusplus >= 201103L
+// expected-error@+3 {{expected}}
+// expected-error@-3 {{expected ';' after top level declarator}}
+#endif
+

Parser/cxx-friend.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
 
 class C {
   friend class D;
 };
 
 class A {
 public:
   void f();
 };
 
 friend int x; // expected-error {{'friend' used outside of class}}
 
 friend class D {}; // expected-error {{'friend' used outside of class}}
 
 union U {
   int u1;
 };
 
 class B {
   // 'A' here should refer to the declaration above.  
   friend class A;
 
-  friend C; // expected-warning {{specify 'class' to befriend}}
-  friend U; // expected-warning {{specify 'union' to befriend}}
-  friend int; // expected-warning {{non-class friend type 'int'}}
+  friend C;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{unelaborated friend declaration is a C++11 extension; specify 'class' to befriend 'C'}}
+#endif
+
+  friend U;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{unelaborated friend declaration is a C++11 extension; specify 'union' to befriend 'U'}}
+#endif
+
+  friend int;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{non-class friend type 'int' is a C++11 extension}}
+#endif
 
   friend void myfunc();
 
   void f(A *a) { a->f(); }
 };
 
 inline void bar() {} // expected-note {{previous definition is here}}
 class E {

SemaCXX/anonymous-struct.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 S {
-  S();  // expected-note {{because type 'S' has a user-provided default constructor}}
+  S();
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{because type 'S' has a user-provided default constructor}}
+#endif
 };
 
 struct { // expected-error {{anonymous structs and classes must be class members}}
 };
 
 struct E {
   struct {
-    S x;  // expected-error {{anonymous struct member 'x' has a non-trivial constructor}}
+    S x;
+#if __cplusplus <= 199711L
+    // expected-error@-2 {{anonymous struct member 'x' has a non-trivial constructor}}
+#endif
   };
   static struct {
   };
 };
 
 template <class T> void foo(T);
-typedef struct { // expected-note {{use a tag name here to establish linkage prior to definition}} expected-note {{declared here}}
+typedef struct { // expected-note {{use a tag name here to establish linkage prior to definition}}
+#if __cplusplus <= 199711L
+// expected-note@-2 {{declared here}}
+#endif
+
   void test() {
-    foo(this); // expected-warning {{template argument uses unnamed type}}
+    foo(this);
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{template argument uses unnamed type}}
+#endif
   }
 } A; // expected-error {{unsupported: typedef changes linkage of anonymous type, but linkage was already computed}}

SemaCXX/class.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wc++11-compat %s 
 class C {
 public:
-  auto int errx; // expected-error {{storage class specified for a member declaration}} expected-warning {{'auto' storage class specifier is redundant}}
+  auto int errx; // expected-error {{storage class specified for a member declaration}}
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{'auto' storage class specifier is redundant}}
+#else
+  // expected-warning@-4 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}}
+#endif
   register int erry; // expected-error {{storage class specified for a member declaration}}
   extern int errz; // expected-error {{storage class specified for a member declaration}}
 
   static void sm() {
     sx = 0;
     this->x = 0; // expected-error {{invalid use of 'this' outside of a non-static member function}}
     x = 0; // expected-error {{invalid use of member 'x' in static member function}}
   }
#endif
   typedef int func();
   func tm;
   func *ptm;
   func btm : 1; // expected-error {{bit-field 'btm' has non-integral type}}
   NestedC bc : 1; // expected-error {{bit-field 'bc' has non-integral type}}
 
   enum E1 { en1, en2 };
 
-  int i = 0; // expected-warning {{in-class initialization of non-static data member is a C++11 extension}}
+  int i = 0;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{in-class initialization of non-static data member is a C++11 extension}}
+#endif
   static int si = 0; // expected-error {{non-const static data member must be initialized out of line}}
   static const NestedC ci = 0; // expected-error {{static data member of type 'const C::NestedC' must be initialized out of line}}
   static const int nci = vs; // expected-error {{in-class initializer for static data member is not a constant expression}}
   static const int vi = 0;
   static const volatile int cvi = 0; // ok, illegal in C++11
+#if __cplusplus >= 201103L
+  // expected-error@-2 {{static const volatile data member must be initialized out of line}}
+#endif
   static const E evi = 0;
 
   void m() {
     sx = 0;
     this->x = 0;
     y = 0;
     this = 0; // expected-error {{expression is not assignable}}
   }

 namespace rdar8066414 {
   class C {
     C() {}
   } // expected-error{{expected ';' after class}}
 }
 
 namespace rdar8367341 {
   float foo();
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{declared here}}
+#endif
 
   struct A {
+#if __cplusplus <= 199711L
     static const float x = 5.0f; // expected-warning {{in-class initializer for static data member of type 'const float' is a GNU extension}}
     static const float y = foo(); // expected-warning {{in-class initializer for static data member of type 'const float' is a GNU extension}} expected-error {{in-class initializer for static data member is not a constant expression}}
+#else
+    static constexpr float x = 5.0f;
+    static constexpr float y = foo(); // expected-error {{constexpr variable 'y' must be initialized by a constant expression}} expected-note {{non-constexpr function 'foo' cannot be used in a constant expression}}
+#endif
   };
 }
 
 namespace with_anon {
 struct S {
   union {
     char c;
   };

SemaCXX/conversion-function.cpp

 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify %s 
+// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify -std=c++98 %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify -std=c++11 %s
+
 class X { 
 public:
   operator bool();
   operator int() const;
 
   bool f() {
     return operator bool();
   }
struct A1 {
   ~A1();
 
 private:
   A1(const A1&); // expected-note 2 {{declared private here}}
 };
 
 A1 f() {
   // FIXME: redundant diagnostics!
-  return "Hello"; // expected-error {{calling a private constructor}} expected-warning {{an accessible copy constructor}}
+  return "Hello"; // expected-error {{calling a private constructor}}
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{an accessible copy constructor}}
+#else
+  // expected-warning@-4 {{copying parameter of type 'A1' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}}
+#endif
 }
 
 namespace source_locations {
   template<typename T>
   struct sneaky_int {
     typedef int type;
   };
 
namespace source_locations {
   E2<int&> e2i; // expected-note{{in instantiation}}
 }
 
 namespace crazy_declarators {
   struct A {
     (&operator bool())(); // expected-error {{use a typedef to declare a conversion to 'bool (&)()'}}
     *operator int();  // expected-error {{put the complete type after 'operator'}}
     // No suggestion of using a typedef here; that's not possible.
-    template<typename T> (&operator T())(); // expected-error-re {{cannot specify any part of a return type in the declaration of a conversion function{{$}}}}
+    template<typename T> (&operator T())();
+#if __cplusplus <= 199711L
+    // expected-error-re@-2 {{cannot specify any part of a return type in the declaration of a conversion function{{$}}}}
+#else
+    // expected-error-re@-4 {{cannot specify any part of a return type in the declaration of a conversion function; use an alias template to declare a conversion to 'T (&)()'{{$}}}}
+#endif
+
   };
 }
 
 namespace smart_ptr {
   class Y { 
     class YRef { };
 
     Y(Y&);
 
   public:
     Y();
     Y(YRef);
 
     operator YRef(); // expected-note{{candidate function}}
   };
 
   struct X { // expected-note{{candidate constructor (the implicit copy constructor) not}}
+#if __cplusplus >= 201103L
+  // expected-note@-2 {{candidate constructor (the implicit move constructor) not}}
+#endif
+
     explicit X(Y);
   };
 
   Y make_Y();
 
   X f() {
     X x = make_Y(); // expected-error{{no viable conversion from 'smart_ptr::Y' to 'smart_ptr::X'}}
     X x2(make_Y());
     return X(Y());
   }
 }
 
 struct Any {
   Any(...);
 };
 
 struct Other {
   Other(const Other &); 
   Other();
 };
 
 void test_any() {
-  Any any = Other(); // expected-error{{cannot pass object of non-POD type 'Other' through variadic constructor; call will abort at runtime}}
+  Any any = Other();
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{cannot pass object of non-POD type 'Other' through variadic constructor; call will abort at runtime}}
+#else
+  // expected-error@-4 {{cannot pass object of non-trivial type 'Other' through variadic constructor; call will abort at runtime}}
+#endif
 }
 
 namespace PR7055 {
   // Make sure that we don't allow too many conversions in an
   // auto_ptr-like template. In particular, we can't create multiple
   // temporary objects when binding to a reference.
   struct auto_ptr {
     struct auto_ptr_ref { };

SemaCXX/cxx1y-variable-templates_in_class.cpp

-// RUN: %clang_cc1 -verify -fsyntax-only %s -Wno-c++11-extensions -Wno-c++1y-extensions -DPRECXX11
+// RUN: %clang_cc1 -std=c++98 -verify -fsyntax-only %s -Wno-c++11-extensions -Wno-c++1y-extensions -DPRECXX11
 // RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s
 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s -DCPP1Y
 
 #define CONST const
 
 #ifdef PRECXX11
 #define static_assert(expr, msg) typedef int static_assert[(expr) ? 1 : -1];
 #endif

SemaCXX/cxx1y-variable-templates_top_level.cpp

-// RUN: %clang_cc1 -verify -fsyntax-only -Wno-c++11-extensions -Wno-c++1y-extensions %s -DPRECXX11
+// RUN: %clang_cc1 -std=c++98 -verify -fsyntax-only -Wno-c++11-extensions -Wno-c++1y-extensions %s -DPRECXX11
 // RUN: %clang_cc1 -std=c++11 -verify -fsyntax-only -Wno-c++1y-extensions %s
 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
 
 #ifdef PRECXX11
   #define CONST const
 #else
   #define CONST constexpr
 #endif

SemaCXX/exceptions.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
 
 struct A; // expected-note 4 {{forward declaration of 'A'}}
 
 struct Abstract { virtual void f() = 0; }; // expected-note {{unimplemented pure virtual method 'f'}}
 
 void trys() {
   try {
   } catch(int i) { // expected-note {{previous definition}}
template<typename T> struct B {
     void f() throw (B[10]);
   };
   template struct B<int>;
 
   void f() throw (int[10], int(*)());
   void f() throw (int*, int());
 
   template<typename T> struct C {
-    void f() throw (T); // expected-error {{pointer to incomplete type 'Decay::E' is not allowed in exception specification}}
+    void f() throw (T);
+#if __cplusplus <= 199711L
+    // expected-error@-2 {{pointer to incomplete type 'Decay::E' is not allowed in exception specification}}
+#endif
   };
   struct D {
     C<D[10]> c;
   };
-  struct E; // expected-note {{forward declaration}}
-  C<E[10]> e; // expected-note {{in instantiation of}}
+  struct E;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{forward declaration of 'Decay::E'}}
+#endif
+
+  C<E[10]> e;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{in instantiation of template class 'Decay::C<Decay::E [10]>' requested here}}
+#endif
 }
 
-void rval_ref() throw (int &&); // expected-error {{rvalue reference type 'int &&' is not allowed in exception specification}} expected-warning {{C++11}}
+void rval_ref() throw (int &&); // expected-error {{rvalue reference type 'int &&' is not allowed in exception specification}}
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{rvalue references are a C++11 extension}}
+#endif
 
 namespace HandlerInversion {
 struct B {};
 struct D : B {};
 struct D2 : D {};
 
 void f1() {
   try {

SemaCXX/qual-id-test.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 A
 {
     namespace B
     {
-        struct base // expected-note{{object type}}
+        struct base
+#if __cplusplus <= 199711L
+        // expected-note@-2 {{lookup in the object type 'A::sub' refers here}}
+#endif
         {
             void x() {}
             void y() {}
         };
     }
 
     struct member
     {
namespace C
     {
         int i;
         i.foo(); // expected-error{{member reference base type 'int' is not a structure or union}}
     }
 
     void fun4a() {
       A::sub *a;
       
-      typedef A::member base; // expected-note{{current scope}}
-      a->base::x(); // expected-error{{ambiguous}}      
+      typedef A::member base;
+#if __cplusplus <= 199711L
+      // expected-note@-2 {{lookup from the current scope refers here}}
+#endif
+      a->base::x();
+#if __cplusplus <= 199711L
+      // expected-error@-2 {{lookup of 'base' in member access expression is ambiguous}}
+#endif
     }
 
     void fun4b() {
       A::sub *a;
       
       typedef A::B::base base;
       a->base::x();
     }

SemaCXX/unused.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
 
 // PR4103 : Make sure we don't get a bogus unused expression warning
 namespace PR4103 {
   class APInt {
     char foo;
   };
   class APSInt : public APInt {
     char bar;
namespace PR4103 {
 
   void test() {
     X<int>();
   }
 }
 
 namespace derefvolatile {
   void f(volatile char* x) {
-    *x; // expected-warning {{expression result unused; assign into a variable to force a volatile load}}
-    (void)*x; // expected-warning {{expression result unused; assign into a variable to force a volatile load}}
+    *x;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{expression result unused; assign into a variable to force a volatile load}}
+#endif
+    (void)*x;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{expression result unused; assign into a variable to force a volatile load}}
+#endif
     volatile char y = 10;
     (void)y; // don't warn here, because it's a common pattern.
   }
 }
 
 // <rdar://problem/12359208>
 namespace AnonObject {
   struct Foo {

SemaCXX/warn-unused-value.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value -std=c++98 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value -std=c++11 %s
 
 // PR4806
 namespace test0 {
   class Box {
   public:
     int i;
     volatile int j;
   };
 
   void doit() {
     // pointer to volatile has side effect (thus no warning)
     Box* box = new Box;
     box->i; // expected-warning {{expression result unused}}
-    box->j; // expected-warning {{expression result unused}}
+    box->j;
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{expression result unused}}
+#endif
   }
 }
 
 namespace test1 {
 struct Foo {
   int i;
   bool operator==(const Foo& rhs) {
     return i == rhs.i;

SemaTemplate/member-access-expr.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>
 void call_f0(T x) {
   x.Base::f0();
 }
 
 struct Base {
   void f0();
 };

 }
 
 void test_f0_through_typedef(X0 x0) {
   call_f0_through_typedef<Base>(x0);
 }
 
 template<typename TheBase, typename T>
 void call_f0_through_typedef2(T x) {
-  typedef TheBase CrazyBase; // expected-note{{current scope}}
-  x.CrazyBase::f0(); // expected-error{{ambiguous}} \
-                     // expected-error 2{{no member named}}
+  typedef TheBase CrazyBase;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{lookup from the current scope refers here}}
+#endif
+
+  x.CrazyBase::f0(); // expected-error 2{{no member named}}
+#if __cplusplus <= 199711L
+  // expected-error@-2 {{lookup of 'CrazyBase' in member access expression is ambiguous}}
+#endif
+
 }
 
 struct OtherBase { };
 
 struct X1 : Base, OtherBase { 
-  typedef OtherBase CrazyBase; // expected-note{{object type}}
+  typedef OtherBase CrazyBase;
+#if __cplusplus <= 199711L
+  // expected-note@-2 {{lookup in the object type 'X1' refers here}}
+#endif
 };
 
 void test_f0_through_typedef2(X0 x0, X1 x1) {
   call_f0_through_typedef2<Base>(x0);
   call_f0_through_typedef2<OtherBase>(x1); // expected-note{{instantiation}}
   call_f0_through_typedef2<Base>(x1); // expected-note{{instantiation}}
 }
 

SemaTemplate/recovery-crash.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
 
 // Clang used to crash trying to recover while adding 'this->' before Work(x);
 
 template <typename> struct A {
   static void Work(int);  // expected-note{{must qualify identifier}}
 };
 
 template <typename T> struct B : public A<T> {

 // Don't crash here.
 namespace PR16134 {
   template <class P> struct S // expected-error {{expected ';'}}
   template <> static S<Q>::f() // expected-error +{{}}
 }
 
 namespace PR16225 {
   template <typename T> void f();
-  template<typename C> void g(C*) {
+  template <typename C> void g(C*) {
     struct LocalStruct : UnknownBase<Mumble, C> { };  // expected-error {{unknown template name 'UnknownBase'}} \
                                                       // expected-error {{use of undeclared identifier 'Mumble'}}
-    f<LocalStruct>();  // expected-warning {{template argument uses local type 'LocalStruct'}}
+    f<LocalStruct>();
+#if __cplusplus <= 199711L
+    // expected-warning@-2 {{template argument uses local type 'LocalStruct'}}
+#endif
   }
   struct S;
   void h() {
-    g<S>(0);  // expected-note {{in instantiation of function template specialization}}
+    g<S>(0);
+#if __cplusplus <= 199711L
+    // expected-note@-2 {{in instantiation of function template specialization}}
+#endif
   }
 }
 
 namespace test1 {
   template <typename> class ArraySlice {};
   class Foo;
   class NonTemplateClass {
     void MemberFunction(ArraySlice<Foo>, int);

SemaTemplate/temp_arg_type.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> class A; // expected-note 2 {{template parameter is declared here}} expected-note{{template is declared here}}
 
 // [temp.arg.type]p1
 A<0> *a1; // expected-error{{template argument for template type parameter must be a type}}
 
 A<A> *a2; // expected-error{{use of class template 'A' requires template arguments}}
 
 A<int> *a3;

 namespace ns {
 template<typename T> class B {};  // expected-note{{template is declared here}}
 }
 A<ns::B> a8; // expected-error{{use of class template 'ns::B' requires template arguments}}
 
 // [temp.arg.type]p2
 void f() {
   class X { };
-  A<X> * a = 0; // expected-warning{{template argument uses local type 'X'}}
+  A<X> * a = 0;
+#if __cplusplus <= 199711L
+  // expected-warning@-2 {{template argument uses local type 'X'}}
+#endif
 }
 
-struct { int x; } Unnamed; // expected-note{{unnamed type used in template argument was declared here}}
-A<__typeof__(Unnamed)> *a9; // expected-warning{{template argument uses unnamed type}}
+struct { int x; } Unnamed;
+#if __cplusplus <= 199711L
+// expected-note@-2 {{unnamed type used in template argument was declared here}}
+#endif
+
+A<__typeof__(Unnamed)> *a9;
+#if __cplusplus <= 199711L
+// expected-warning@-2 {{template argument uses unnamed type}}
+#endif
 
 template<typename T, unsigned N>
 struct Array {
   typedef struct { T x[N]; } type;
 };
 
 template<typename T> struct A1 { };
 A1<Array<int, 17>::type> ax;
 
 // FIXME: [temp.arg.type]p3. The check doesn't really belong here (it
 // belongs somewhere in the template instantiation section).