Make some diagnostic tests C++11 clean

[probinson]

Summary

Another half-dozen test revisions in the ongoing campaign to make things ready for C++11 as Clangs's default dialect.

Most of these are straightforward, but I am not entirely sure about a couple of things:

• In fixit.cpp, the place that now gets 'expected unqualified-id' seems funny, but maybe that's just the nature of things
• In copy-assignment.cpp, I am bemused by the whole thing but especially 'passing argument to parameter here'

[probinson]

+abataev for OpenMP.

[ABataev]

LG for OpenMP part

[probinson]

Remove the OpenMP tests from this review (committed in r290128).

+rnk who added test/Parser/backtrack-off-by-one.cpp originally.

[rnk]

Everything here looks good to me.

test/FixIt/fixit.cpp

28 ↗

(On Diff #81977)

I guess in C++11 we now parse this as CT<10> > 2 > ct;. I'd add a FIXME comment here to re-enable this recovery in C++11.

[probinson]

FIXME added.

cfe/trunk/test/FixIt/fixit.cpp

-// RUN: %clang_cc1 -pedantic -Wall -Wno-comment -verify -fcxx-exceptions -x c++ %s
+// RUN: %clang_cc1 -pedantic -Wall -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++98 %s
+// RUN: cp %s %t-98
+// RUN: not %clang_cc1 -pedantic -Wall -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++98 %t-98
+// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-comment -fcxx-exceptions -x c++ -std=c++98 %t-98
 // RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -x c++ -std=c++11 %s 2>&1 | FileCheck %s
-// RUN: cp %s %t
-// RUN: not %clang_cc1 -pedantic -Wall -Wno-comment -fcxx-exceptions -fixit -x c++ %t
-// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-comment -fcxx-exceptions -x c++ %t
+// RUN: %clang_cc1 -pedantic -Wall -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++11 %s
+// RUN: cp %s %t-11
+// RUN: not %clang_cc1 -pedantic -Wall -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++11 %t-11
+// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-comment -fcxx-exceptions -x c++ -std=c++11 %t-11
 
 /* This is a test of the various code modification hints that are
    provided as part of warning or extension diagnostics. All of the
    warnings will be fixed by -fixit, and the resulting file should
    compile cleanly with -Werror -pedantic. */
 
 struct C1 {
   virtual void f();
   static void g();
 };
 struct C2 : virtual public virtual C1 { }; // expected-error{{duplicate}}
 
 virtual void C1::f() { } // expected-error{{'virtual' can only be specified inside the class definition}}
 
 static void C1::g() { } // expected-error{{'static' can only be specified inside the class definition}}
 
 template<int Value> struct CT { template<typename> struct Inner; }; // expected-note{{previous use is here}}
 
+// FIXME: In C++11 this gets 'expected unqualified-id' which fixit can't fix.
+// Probably parses as `CT<10> > 2 > ct;` rather than `CT<(10 >> 2)> ct;`.
+#if __cplusplus < 201103L
 CT<10 >> 2> ct; // expected-warning{{require parentheses}}
+#endif
 
 class C3 {
 public:
   C3(C3, int i = 0); // expected-error{{copy constructor must pass its first argument by reference}}
 };
 
 struct CT<0> { }; // expected-error{{'template<>'}}
 
 template<> union CT<1> { }; // expected-error{{tag type}}
 
 struct CT<2>::Inner<int> { }; // expected-error 2{{'template<>'}}
 
 // Access declarations
 class A {
 protected:
   int foo();
 };
 
 class B : public A {
+#if __cplusplus >= 201103L
+  A::foo; // expected-error{{ISO C++11 does not allow access declarations}}
+#else
   A::foo; // expected-warning{{access declarations are deprecated}}
+#endif
 };
 
 void f() throw(); // expected-note{{previous}}
 void f(); // expected-error{{missing exception specification}}
 
 namespace rdar7853795 {
   struct A {
     bool getNumComponents() const; // expected-note{{declared here}}
namespace greatergreater {
 
   template<template<typename>> struct TemplateTemplateParam; // expected-error {{requires 'class'}}
 
   template<typename T> void t();
   void g() {
     void (*p)() = &t<int>;
     (void)(&t<int>==p); // expected-error {{use '> ='}}
     (void)(&t<int>>=p); // expected-error {{use '> >'}}
+#if __cplusplus < 201103L
     (void)(&t<S<int>>>=p); // expected-error {{use '> >'}}
     (Shr)&t<S<int>>>>=p; // expected-error {{use '> >'}}
+#endif
 
     // FIXME: We correct this to '&t<int> > >= p;' not '&t<int> >>= p;'
     //(Shr)&t<int>>>=p;
 
     // FIXME: The fix-its here overlap.
     //(void)(&t<S<int>>==p);
   }
 }

cfe/trunk/test/Parser/backtrack-off-by-one.cpp

 // RUN: %clang_cc1 -verify %s
+// RUN: %clang_cc1 -verify %s -std=c++98
+// RUN: %clang_cc1 -verify %s -std=c++11
 
 // PR25946
 // We had an off-by-one error in an assertion when annotating A<int> below.  Our
 // error recovery checks if A<int> is a constructor declarator, and opens a
 // TentativeParsingAction. Then we attempt to annotate the token at the exact
 // position that we want to possibly backtrack to, and this used to crash.
 
 template <typename T> class A {};
 
 // expected-error@+1 {{expected '{' after base class list}}
 template <typename T> class B : T // not ',' or '{'
-// expected-error@+3 {{C++ requires a type specifier for all declarations}}
-// expected-error@+2 {{expected ';' after top level declarator}}
+#if __cplusplus < 201103L
+// expected-error@+4 {{expected ';' after top level declarator}}
+#endif
+// expected-error@+2 {{C++ requires a type specifier for all declarations}}
 // expected-error@+1 {{expected ';' after class}}
 A<int> {
 };

cfe/trunk/test/SemaCXX/copy-assignment.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s 
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++98
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+
+#if __cplusplus >= 201103L
+// expected-note@+3 2 {{candidate constructor}}
+// expected-note@+2 {{passing argument to parameter here}}
+#endif
 struct A {
 };
 
 struct ConvertibleToA {
   operator A();
 };
 
 struct ConvertibleToConstA {
+#if __cplusplus >= 201103L
+// expected-note@+2 {{candidate function}}
+#endif
   operator const A();
 };
 
 struct B {
   B& operator=(B&);  // expected-note 4 {{candidate function}}
 };
 
 struct ConvertibleToB {
void test() {
   D d, nd;
   const D constD = D();
 
   ConvertibleToInt convertibleToInt;
 
   na = a;
   na = constA;
   na = convertibleToA;
+#if __cplusplus >= 201103L
+// expected-error@+2 {{no viable conversion}}
+#endif
   na = convertibleToConstA;
   na += a; // expected-error{{no viable overloaded '+='}}
 
   nb = b;
   nb = constB;  // expected-error{{no viable overloaded '='}}
   nb = convertibleToB; // expected-error{{no viable overloaded '='}}
   nb = convertibleToBref;
   nb = convertibleToConstB; // expected-error{{no viable overloaded '='}}