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 }
g()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 };
S()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