1// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 2 3// New exciting ambiguities in C++11 4 5// final 'context sensitive' mess. 6namespace final { 7 struct S { int n; }; 8 struct T { int n; }; 9 namespace N { 10 int n; 11 // These declare variables named final.. 12 extern struct S final; 13 extern struct S final [[]]; 14 extern struct S final, foo; 15 struct S final = S(); 16 17 // This defines a class, not a variable, even though it would successfully 18 // parse as a variable but not as a class. DR1318's wording suggests that 19 // this disambiguation is only performed on an ambiguity, but that was not 20 // the intent. 21 struct S final { // expected-note {{here}} 22 int(n) // expected-error {{expected ';'}} 23 }; 24 // This too. 25 struct T final : S {}; // expected-error {{base 'S' is marked 'final'}} 26 struct T bar : S {}; // expected-error {{expected ';' after top level declarator}} expected-error {{expected unqualified-id}} 27 } 28} 29 30// enum versus bitfield mess. 31namespace bitfield { 32 enum E {}; 33 34 struct T { 35 constexpr T() {} 36 constexpr T(int) {} 37 constexpr T(T, T, T, T) {} 38 constexpr T operator=(T) { return *this; } 39 constexpr operator int() { return 4; } 40 }; 41 constexpr T a, b, c, d; 42 43 struct S1 { 44 enum E : T ( a = 1, b = 2, c = 3, 4 ); // ok, declares a bitfield 45 }; 46 // This could be a bit-field. 47 struct S2 { 48 enum E : T { a = 1, b = 2, c = 3, 4 }; // expected-error {{non-integral type}} expected-error {{expected '}'}} expected-note {{to match}} 49 }; 50 struct S3 { 51 enum E : int { a = 1, b = 2, c = 3, d }; // ok, defines an enum 52 }; 53 // Ambiguous. 54 struct S4 { 55 enum E : int { a = 1 }; // ok, defines an enum 56 }; 57 // This could be a bit-field, but would be ill-formed due to the anonymous 58 // member being initialized. 59 struct S5 { 60 enum E : int { a = 1 } { b = 2 }; // expected-error {{expected ';' after enum}} expected-error {{expected member name}} 61 }; 62 // This could be a bit-field. 63 struct S6 { 64 enum E : int { 1 }; // expected-error {{expected '}'}} expected-note {{to match}} 65 }; 66 67 struct U { 68 constexpr operator T() { return T(); } // expected-note 2{{candidate}} 69 }; 70 // This could be a bit-field. 71 struct S7 { 72 enum E : int { a = U() }; // expected-error {{no viable conversion}} 73 }; 74 // This could be a bit-field, and does not conform to the grammar of an 75 // enum definition, because 'id(U())' is not a constant-expression. 76 constexpr const U &id(const U &u) { return u; } 77 struct S8 { 78 enum E : int { a = id(U()) }; // expected-error {{no viable conversion}} 79 }; 80} 81 82namespace trailing_return { 83 typedef int n; 84 int a; 85 86 struct S { 87 S(int); 88 S *operator()(...) const; 89 int n; 90 }; 91 92 namespace N { 93 void f() { 94 // This parses as a function declaration, but DR1223 makes the presence of 95 // 'auto' be used for disambiguation. 96 S(a)()->n; // ok, expression; expected-warning{{expression result unused}} 97 S(a)(int())->n; // ok, expression; expected-warning{{expression result unused}} 98 auto(a)()->n; // ok, function declaration 99 auto(b)(int())->n; // ok, function declaration 100 using T = decltype(a); 101 using T = auto() -> n; 102 } 103 } 104} 105 106namespace ellipsis { 107 template<typename...T> 108 struct S { 109 void e(S::S()); 110 void f(S(...args[sizeof(T)])); // expected-note {{here}} 111 void f(S(...args)[sizeof(T)]); // expected-error {{redeclared}} expected-note {{here}} 112 void f(S ...args[sizeof(T)]); // expected-error {{redeclared}} 113 void g(S(...[sizeof(T)])); // expected-note {{here}} 114 void g(S(...)[sizeof(T)]); // expected-error {{function cannot return array type}} 115 void g(S ...[sizeof(T)]); // expected-error {{redeclared}} 116 void h(T(...)); // function type, expected-error {{unexpanded parameter pack}} 117 void h(T...); // pack expansion, ok 118 void i(int(T...)); // expected-note {{here}} 119 void i(int(T...a)); // expected-error {{redeclared}} 120 void i(int(T, ...)); // function type, expected-error {{unexpanded parameter pack}} 121 void i(int(T, ...a)); // expected-error {{expected ')'}} expected-note {{to match}} expected-error {{unexpanded parameter pack}} 122 void j(int(int...)); // function type, ok 123 void j(int(int...a)); // expected-error {{does not contain any unexpanded parameter packs}} 124 void j(T(int...)); // expected-error {{unexpanded parameter pack}} 125 void j(T(T...)); // expected-error {{unexpanded parameter pack}} 126 void k(int(...)(T)); // expected-error {{cannot return function type}} 127 void k(int ...(T)); 128 }; 129} 130