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