1 // RUN: %clang_cc1 -verify -std=c++11 -Wno-anonymous-pack-parens %s 2 // RUN: cp %s %t 3 // RUN: not %clang_cc1 -x c++ -std=c++11 -fixit %t 4 // RUN: %clang_cc1 -Wall -pedantic -x c++ -std=c++11 %t 5 6 /* This is a test of the various code modification hints that only 7 apply in C++0x. */ 8 struct A { 9 explicit operator int(); // expected-note{{conversion to integral type}} 10 }; 11 12 void x() { 13 switch(A()) { // expected-error{{explicit conversion to}} 14 } 15 } 16 17 using ::T = void; // expected-error {{name defined in alias declaration must be an identifier}} 18 using typename U = void; // expected-error {{name defined in alias declaration must be an identifier}} 19 using typename ::V = void; // expected-error {{name defined in alias declaration must be an identifier}} 20 21 namespace SemiCommaTypo { 22 int m {}, 23 n [[]], // expected-error {{expected ';' at end of declaration}} 24 int o; 25 26 struct Base { 27 virtual void f2(), f3(); 28 }; 29 struct MemberDeclarator : Base { 30 int k : 4, 31 //[[]] : 1, FIXME: test this once we support attributes here 32 : 9, // expected-error {{expected ';' at end of declaration}} 33 char c, // expected-error {{expected ';' at end of declaration}} 34 typedef void F(), // expected-error {{expected ';' at end of declaration}} 35 F f1, 36 f2 final, 37 f3 override, // expected-error {{expected ';' at end of declaration}} 38 }; 39 } 40 41 namespace ScopedEnum { 42 enum class E { a }; 43 44 enum class E b = E::a; // expected-error {{must use 'enum' not 'enum class'}} 45 struct S { 46 friend enum class E; // expected-error {{must use 'enum' not 'enum class'}} 47 // expected-warning@-1 {{elaborated enum specifier cannot be declared as a friend}} 48 // expected-note@-2 {{remove 'enum class' to befriend an enum}} 49 }; 50 } 51 52 struct S2 { 53 void f(int i); 54 void g(int i); 55 }; 56 57 void S2::f(int i) { 58 (void)[&, &i, &i]{}; // expected-error 2{{'&' cannot precede a capture when the capture default is '&'}} 59 (void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}} 60 (void)[&, i, i]{ }; // expected-error{{'i' can appear only once in a capture list}} 61 (void)[] mutable {}; 62 (void)[]->int{ return 0; }; 63 #if __cplusplus <= 202002L 64 // expected-warning@-3{{is a C++23 extension}} 65 // expected-warning@-3{{is a C++23 extension}} 66 #endif 67 68 delete []() { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}} 69 delete [] { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}} 70 } 71 72 #define bar "bar" 73 const char *p = "foo"bar; // expected-error {{requires a space between}} 74 #define ord - '0' 75 int k = '4'ord; // expected-error {{requires a space between}} 76 77 void operator"x"_y(char); // expected-error {{must be '""'}} 78 void operator L""_z(char); // expected-error {{encoding prefix}} 79 void operator "x" "y" U"z" ""_whoops "z" "y"(char); // expected-error {{must be '""'}} 80 81 void f() { 82 'b'_y; 83 'c'_z; 84 'd'_whoops; 85 } 86 87 template<typename ...Ts> struct MisplacedEllipsis { 88 int a(Ts ...(x)); // expected-error {{'...' must immediately precede declared identifier}} 89 int b(Ts ...&x); // expected-error {{'...' must immediately precede declared identifier}} 90 int c(Ts ...&); // expected-error {{'...' must be innermost component of anonymous pack declaration}} 91 int d(Ts ...(...&...)); // expected-error 2{{'...' must be innermost component of anonymous pack declaration}} 92 int e(Ts ...*[]); // expected-error {{'...' must be innermost component of anonymous pack declaration}} 93 int f(Ts ...(...*)()); // expected-error 2{{'...' must be innermost component of anonymous pack declaration}} 94 int g(Ts ...()); // ok 95 }; 96 namespace TestMisplacedEllipsisRecovery { 97 MisplacedEllipsis<int, char> me; 98 int i; char k; 99 int *ip; char *kp; 100 int ifn(); char kfn(); 101 int a = me.a(i, k); 102 int b = me.b(i, k); 103 int c = me.c(i, k); 104 int d = me.d(i, k); 105 int e = me.e(&ip, &kp); 106 int f = me.f(ifn, kfn); 107 int g = me.g(ifn, kfn); 108 } 109 110 template<template<typename> ...Foo, // expected-error {{template template parameter requires 'class' after the parameter list}} 111 template<template<template<typename>>>> // expected-error 3 {{template template parameter requires 'class' after the parameter list}} 112 void func(); 113 114 template<int *ip> struct IP { }; // expected-note{{declared here}} 115 IP<0> ip0; // expected-error{{null non-type template argument must be cast to template parameter type 'int *'}} 116 117 namespace MissingSemi { 118 struct a // expected-error {{expected ';' after struct}} 119 struct b // expected-error {{expected ';' after struct}} 120 enum x : int { x1, x2, x3 } // expected-error {{expected ';' after enum}} 121 struct c // expected-error {{expected ';' after struct}} 122 enum x : int // expected-error {{expected ';' after enum}} 123 // FIXME: The following gives a poor diagnostic (we parse the 'int' and the 124 // 'struct' as part of the same enum-base. 125 // enum x : int 126 // struct y 127 namespace N { 128 struct d // expected-error {{expected ';' after struct}} 129 } 130 } 131 132 namespace NonStaticConstexpr { 133 struct foo { 134 constexpr int i; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}} 135 constexpr int j = 7; // expected-error {{non-static data member cannot be constexpr; did you intend to make it static?}} 136 constexpr const int k; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}} 137 foo() : i(3), k(4) { 138 } 139 static int get_j() { 140 return j; 141 } 142 }; 143 } 144 145 int RegisterVariable() { 146 register int n; // expected-warning {{'register' storage class specifier is deprecated}} 147 return n; 148 } 149 150 namespace MisplacedParameterPack { 151 template <typename Args...> // expected-error {{'...' must immediately precede declared identifier}} 152 void misplacedEllipsisInTypeParameter(Args...); 153 154 template <typename... Args...> // expected-error {{'...' must immediately precede declared identifier}} 155 void redundantEllipsisInTypeParameter(Args...); 156 157 template <template <typename> class Args...> // expected-error {{'...' must immediately precede declared identifier}} 158 void misplacedEllipsisInTemplateTypeParameter(Args<int>...); 159 160 template <template <typename> class... Args...> // expected-error {{'...' must immediately precede declared identifier}} 161 void redundantEllipsisInTemplateTypeParameter(Args<int>...); 162 163 template <int N...> // expected-error {{'...' must immediately precede declared identifier}} 164 void misplacedEllipsisInNonTypeTemplateParameter(); 165 166 template <int... N...> // expected-error {{'...' must immediately precede declared identifier}} 167 void redundantEllipsisInNonTypeTemplateParameter(); 168 } 169 170 namespace MisplacedDeclAndRefSpecAfterVirtSpec { 171 struct B { 172 virtual void f(); 173 virtual void f() volatile const; 174 }; 175 struct D : B { 176 virtual void f() override; 177 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'}} 178 }; 179 struct B2 { 180 virtual void f() &; 181 virtual void f() volatile const &&; 182 }; 183 struct D2 : B2 { 184 virtual void f() override &; // expected-error {{'&' qualifier may not appear after the virtual specifier 'override'}} 185 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'}} 186 }; 187 } 188