Give 'fixit-cxx0x.cpp' a more modern name.

llvm-svn: 361208

1 files changed, 181 insertions, 0 deletions

diff --git a/clang/test/FixIt/fixit-c++11.cpp b/clang/test/FixIt/fixit-c++11.cpp
new file mode 100644
index 00000000000..70342075a15
--- /dev/null
+++ b/clang/test/FixIt/fixit-c++11.cpp
@@ -0,0 +1,181 @@
+// RUN: %clang_cc1 -verify -std=c++11 -Wno-anonymous-pack-parens %s
+// RUN: cp %s %t
+// RUN: not %clang_cc1 -x c++ -std=c++11 -fixit %t
+// RUN: %clang_cc1 -Wall -pedantic -x c++ -std=c++11 %t
+
+/* This is a test of the various code modification hints that only
+   apply in C++0x. */
+struct A {
+  explicit operator int(); // expected-note{{conversion to integral type}}
+};
+
+void x() {
+  switch(A()) { // expected-error{{explicit conversion to}}
+  }
+}
+
+using ::T = void; // expected-error {{name defined in alias declaration must be an identifier}}
+using typename U = void; // expected-error {{name defined in alias declaration must be an identifier}}
+using typename ::V = void; // expected-error {{name defined in alias declaration must be an identifier}}
+
+namespace SemiCommaTypo {
+  int m {},
+  n [[]], // expected-error {{expected ';' at end of declaration}}
+  int o;
+
+  struct Base {
+    virtual void f2(), f3();
+  };
+  struct MemberDeclarator : Base {
+    int k : 4,
+        //[[]] : 1, FIXME: test this once we support attributes here
+        : 9, // expected-error {{expected ';' at end of declaration}}
+    char c, // expected-error {{expected ';' at end of declaration}}
+    typedef void F(), // expected-error {{expected ';' at end of declaration}}
+    F f1,
+      f2 final,
+      f3 override, // expected-error {{expected ';' at end of declaration}}
+  };
+}
+
+namespace ScopedEnum {
+  enum class E { a };
+
+  enum class E b = E::a; // expected-error {{must use 'enum' not 'enum class'}}
+  struct S {
+    friend enum class E; // expected-error {{must use 'enum' not 'enum class'}}
+  };
+}
+
+struct S2 { 
+  void f(int i); 
+  void g(int i);
+};
+
+void S2::f(int i) {
+  (void)[&, &i, &i]{}; // expected-error 2{{'&' cannot precede a capture when the capture default is '&'}}
+  (void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
+  (void)[&, i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
+  (void)[] mutable { }; // expected-error{{lambda requires '()' before 'mutable'}}
+  (void)[] -> int { }; // expected-error{{lambda requires '()' before return type}}
+
+  delete []() { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}}
+  delete [] { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}}
+}
+
+#define bar "bar"
+const char *p = "foo"bar; // expected-error {{requires a space between}}
+#define ord - '0'
+int k = '4'ord; // expected-error {{requires a space between}}
+
+void operator"x" _y(char); // expected-error {{must be '""'}}
+void operator L"" _z(char); // expected-error {{encoding prefix}}
+void operator "x" "y" U"z" ""_whoops "z" "y"(char); // expected-error {{must be '""'}}
+
+void f() {
+  'b'_y;
+  'c'_z;
+  'd'_whoops;
+}
+
+template<typename ...Ts> struct MisplacedEllipsis {
+  int a(Ts ...(x)); // expected-error {{'...' must immediately precede declared identifier}}
+  int b(Ts ...&x); // expected-error {{'...' must immediately precede declared identifier}}
+  int c(Ts ...&); // expected-error {{'...' must be innermost component of anonymous pack declaration}}
+  int d(Ts ...(...&...)); // expected-error 2{{'...' must be innermost component of anonymous pack declaration}}
+  int e(Ts ...*[]); // expected-error {{'...' must be innermost component of anonymous pack declaration}}
+  int f(Ts ...(...*)()); // expected-error 2{{'...' must be innermost component of anonymous pack declaration}}
+  int g(Ts ...()); // ok
+};
+namespace TestMisplacedEllipsisRecovery {
+  MisplacedEllipsis<int, char> me;
+  int i; char k;
+  int *ip; char *kp;
+  int ifn(); char kfn();
+  int a = me.a(i, k);
+  int b = me.b(i, k);
+  int c = me.c(i, k);
+  int d = me.d(i, k);
+  int e = me.e(&ip, &kp);
+  int f = me.f(ifn, kfn);
+  int g = me.g(ifn, kfn);
+}
+
+template<template<typename> ...Foo, // expected-error {{template template parameter requires 'class' after the parameter list}}
+         template<template<template<typename>>>> // expected-error 3 {{template template parameter requires 'class' after the parameter list}}
+void func();
+
+template<int *ip> struct IP { }; // expected-note{{declared here}}
+IP<0> ip0; // expected-error{{null non-type template argument must be cast to template parameter type 'int *'}}
+
+namespace MissingSemi {
+  struct a // expected-error {{expected ';' after struct}}
+  struct b // expected-error {{expected ';' after struct}}
+  enum x : int { x1, x2, x3 } // expected-error {{expected ';' after enum}}
+  struct c // expected-error {{expected ';' after struct}}
+  enum x : int // expected-error {{expected ';' after enum}}
+  // FIXME: The following gives a poor diagnostic (we parse the 'int' and the
+  // 'struct' as part of the same enum-base.
+  //   enum x : int
+  //   struct y
+  namespace N {
+    struct d // expected-error {{expected ';' after struct}}
+  }
+}
+
+namespace NonStaticConstexpr {
+  struct foo {
+    constexpr int i; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
+    constexpr int j = 7; // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}}
+    constexpr const int k; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}}
+    foo() : i(3), k(4) {
+    }
+    static int get_j() {
+      return j;
+    }
+  };
+}
+
+int RegisterVariable() {
+  register int n; // expected-warning {{'register' storage class specifier is deprecated}}
+  return n;
+}
+
+namespace MisplacedParameterPack {
+  template <typename Args...> // expected-error {{'...' must immediately precede declared identifier}}
+  void misplacedEllipsisInTypeParameter(Args...);
+
+  template <typename... Args...> // expected-error {{'...' must immediately precede declared identifier}}
+  void redundantEllipsisInTypeParameter(Args...);
+
+  template <template <typename> class Args...> // expected-error {{'...' must immediately precede declared identifier}}
+  void misplacedEllipsisInTemplateTypeParameter(Args<int>...);
+
+  template <template <typename> class... Args...> // expected-error {{'...' must immediately precede declared identifier}}
+  void redundantEllipsisInTemplateTypeParameter(Args<int>...);
+
+  template <int N...> // expected-error {{'...' must immediately precede declared identifier}}
+  void misplacedEllipsisInNonTypeTemplateParameter();
+
+  template <int... N...> // expected-error {{'...' must immediately precede declared identifier}}
+  void redundantEllipsisInNonTypeTemplateParameter();
+}
+
+namespace MisplacedDeclAndRefSpecAfterVirtSpec {
+  struct B {
+    virtual void f();
+    virtual void f() volatile const;
+  };
+  struct D : B {
+    virtual void f() override;
+    virtual void f() override final const volatile; // expected-error {{'const' qualifier may not appear after the virtual specifier 'final'}} expected-error {{'volatile' qualifier may not appear after the virtual specifier 'final'}}
+  };
+  struct B2 {
+    virtual void f() &;
+    virtual void f() volatile const &&;
+  };
+  struct D2 : B2 {
+    virtual void f() override &; // expected-error {{'&' qualifier may not appear after the virtual specifier 'override'}}
+    virtual void f() override final const volatile &&; //  expected-error {{'const' qualifier may not appear after the virtual specifier 'final'}} expected-error {{'volatile' qualifier may not appear after the virtual specifier 'final'}} expected-error {{'&&' qualifier may not appear after the virtual specifier 'final'}}
+  };
+}