1 // RUN: %clang_cc1 -verify -std=c++11 -fms-extensions %s 2 3 8gi///===--- recovery.cpp ---===// // expected-error {{unqualified-id}} 4 namespace Std { // expected-note {{here}} 5 typedef int Important; 6 } 7 8 / redeclare as an inline namespace // expected-error {{unqualified-id}} 9 inline namespace Std { // expected-error {{cannot be reopened as inline}} 10 Important n; 11 } / end namespace Std // expected-error {{unqualified-id}} 12 int x; 13 Std::Important y; 14 15 extenr "C" { // expected-error {{did you mean 'extern'}} 16 void f(); 17 } 18 void g() { 19 z = 1; // expected-error {{undeclared}} 20 f(); 21 } 22 23 struct S { 24 int a, b, c; 25 S(); 26 int x // expected-error {{expected ';'}} 27 friend void f() 28 }; 29 8S::S() : a{ 5 }, b{ 6 }, c{ 2 } { // expected-error {{unqualified-id}} 30 return; 31 } 32 int k; 33 int l = k // expected-error {{expected ';'}} 34 constexpr int foo(); 35 36 5int m = { l }, n = m; // expected-error {{unqualified-id}} 37 38 namespace MissingBrace { 39 struct S { // expected-error {{missing '}' at end of definition of 'MissingBrace::S'}} 40 int f(); 41 // }; 42 43 namespace N { int g(); } // expected-note {{still within definition of 'MissingBrace::S' here}} 44 45 int k1 = S().h(); // expected-error {{no member named 'h' in 'MissingBrace::S'}} 46 int k2 = S().f() + N::g(); 47 48 template<typename T> struct PR17949 { // expected-error {{missing '}' at end of definition of 'MissingBrace::PR17949'}} 49 50 namespace X { // expected-note {{still within definition of 'MissingBrace::PR17949' here}} 51 } 52 } 53 54 namespace N { 55 int 56 } // expected-error {{unqualified-id}} 57 58 strcut Uuuu { // expected-error {{did you mean 'struct'}} \ 59 // expected-note {{'Uuuu' declared here}} 60 } *u[3]; 61 uuuu v; // expected-error {{did you mean 'Uuuu'}} 62 63 struct Redefined { // expected-note {{previous}} 64 Redefined() {} 65 }; 66 struct Redefined { // expected-error {{redefinition}} 67 Redefined() {} 68 }; 69 70 struct MissingSemi5; 71 namespace N { 72 typedef int afterMissingSemi4; 73 extern MissingSemi5 afterMissingSemi5; 74 } 75 76 struct MissingSemi1 {} // expected-error {{expected ';' after struct}} 77 static int afterMissingSemi1(); 78 79 class MissingSemi2 {} // expected-error {{expected ';' after class}} 80 MissingSemi1 *afterMissingSemi2; 81 82 enum MissingSemi3 {} // expected-error {{expected ';' after enum}} 83 ::MissingSemi1 afterMissingSemi3; 84 85 extern N::afterMissingSemi4 afterMissingSemi4b; 86 union MissingSemi4 { MissingSemi4(int); } // expected-error {{expected ';' after union}} 87 N::afterMissingSemi4 (afterMissingSemi4b); 88 89 int afterMissingSemi5b; 90 struct MissingSemi5 { MissingSemi5(int); } // ok, no missing ';' here 91 N::afterMissingSemi5 (afterMissingSemi5b); 92 93 template<typename T> struct MissingSemiT { 94 } // expected-error {{expected ';' after struct}} 95 MissingSemiT<int> msi; 96 97 struct MissingSemiInStruct { 98 struct Inner1 {} // expected-error {{expected ';' after struct}} 99 static MissingSemi5 ms1; 100 101 struct Inner2 {} // ok, no missing ';' here 102 static MissingSemi1; 103 104 struct Inner3 {} // expected-error {{expected ';' after struct}} 105 static MissingSemi5 *p; 106 }; 107 108 void MissingSemiInFunction() { 109 struct Inner1 {} // expected-error {{expected ';' after struct}} 110 if (true) {} 111 112 // FIXME: It would be nice to at least warn on this. 113 struct Inner2 { Inner2(int); } // ok, no missing ';' here 114 k = l; 115 116 struct Inner3 {} // expected-error {{expected ';' after struct}} 117 Inner1 i1; 118 119 struct Inner4 {} // ok, no missing ';' here 120 Inner5; 121 } 122 123 namespace NS { 124 template<typename T> struct Foo {}; 125 } 126 struct MissingSemiThenTemplate1 {} // expected-error {{expected ';' after struct}} 127 NS::Foo<int> missingSemiBeforeFunctionReturningTemplateId1(); 128 129 using NS::Foo; 130 struct MissingSemiThenTemplate2 {} // expected-error {{expected ';' after struct}} 131 Foo<int> missingSemiBeforeFunctionReturningTemplateId2(); 132 133 namespace PR17084 { 134 enum class EnumID {}; 135 template <typename> struct TempID; 136 template <> struct TempID<BadType> : BadType, EnumID::Garbage; // expected-error{{use of undeclared identifier 'BadType'}} 137 } 138 139 namespace pr15133 { 140 namespace ns { 141 const int V1 = 1; // expected-note {{declared here}} 142 } 143 struct C1 { 144 enum E1 { V2 = 2 }; // expected-note {{declared here}} 145 static const int V3 = 3; // expected-note {{declared here}} 146 }; 147 enum E2 { 148 V4 = 4, // expected-note {{declared here}} 149 V6 // expected-note {{declared here}} 150 }; 151 enum class EC3 { V0 = 0, V5 = 5 }; // expected-note {{declared here}} 152 void func_3(); 153 154 void func_1(int x) { 155 switch(x) { 156 case 0: break; 157 case ns::V1:: break; // expected-error{{'V1' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 158 case C1::V2:: break; // expected-error{{'V2' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 159 case C1::V3:: break; // expected-error{{'V3' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 160 case V4:: break; // expected-error{{'V4' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 161 case V6:: func_3(); // expected-error{{'V6' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 162 } 163 } 164 void func_2(EC3 x) { 165 switch(x) { 166 case EC3::V0: break; 167 case EC3::V5:: break; // expected-error{{'V5' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 168 } 169 } 170 171 template<class T> struct TS1 { 172 typedef int A; 173 }; 174 template<class T> void func(int x) { 175 switch(x) { 176 case TS1<T>::A:: break; // expected-error{{expected unqualified-id}} 177 } 178 }; 179 void mainf() { 180 func<int>(1); 181 } 182 183 struct S { 184 static int n; // expected-note{{declared here}} 185 int nn; // expected-note 2 {{declared here}} 186 }; 187 188 int func_3(int x) { 189 return x ? S::n :: 0; // expected-error{{'n' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 190 } 191 int func_4(int x, S &s) { 192 return x ? s.nn :: x; // expected-error{{'nn' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 193 } 194 int func_5(int x, S &s) { 195 return x ? s.nn :: S::n; // expected-error{{'nn' cannot appear before '::' because it is not a class, namespace, or enumeration; did you mean ':'?}} 196 } 197 198 struct S2 { 199 struct S3; 200 }; 201 202 struct S2 :: S3 :: public S2 { // expected-error{{'public' cannot be a part of nested name specifier; did you mean ':'?}} 203 }; 204 } 205 206 namespace InvalidEmptyNames { 207 // These shouldn't crash, the diagnostics aren't important. 208 struct ::, struct ::; // expected-error 2 {{expected identifier}} expected-error 2 {{declaration of anonymous struct must be a definition}} expected-warning {{declaration does not declare anything}} 209 enum ::, enum ::; // expected-error 2 {{expected identifier}} expected-warning {{declaration does not declare anything}} 210 struct ::__super, struct ::__super; // expected-error 2 {{expected identifier}} expected-error 2 {{expected '::' after '__super'}} 211 struct ::template foo, struct ::template bar; // expected-error 2 {{expected identifier}} expected-error 2 {{declaration of anonymous struct must be a definition}} expected-warning {{declaration does not declare anything}} 212 struct ::foo struct::; // expected-error {{no struct named 'foo' in the global namespace}} expected-error {{expected identifier}} expected-error {{declaration of anonymous struct must be a definition}} 213 class :: : {} a; // expected-error {{expected identifier}} expected-error {{expected class name}} 214 } 215
