1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2 
3 struct x {
4   x() : a(4) ; // expected-error {{expected '{'}}
5 };
6 
7 struct y {
8   int a;
9   y() : a(4) ; // expected-error {{expected '{'}}
10 };
11 
12 struct z {
13   int a;
14   z() : a {}
15 }; // expected-error {{expected '{'}}
16 
17 namespace PR16480 {
18   template<int n> struct X {
19     X();
20     X(int);
21   };
22 
23   struct A : X<0> {
APR16480::A24     A() : X<a<b>{0}.n>() {}
25 
26     template<int> struct a {
27       int n;
28     };
29 
30     static const int b = 1;
31   };
32 
33   struct B : X<0> {
BPR16480::B34     B() : X<a<b>{0} {}
35 
36     static const int a = 0, b = 0;
37   };
38 
39   template<int> struct a {
aPR16480::a40     constexpr a(int) {}
operator intPR16480::a41     constexpr operator int() const { return 0; }
42   };
43 
44   struct C : X<0> {
CPR16480::C45     C() : X<a<b>(0)>() {}
46 
47     static const int b = 0;
48   };
49 
50   struct D : X<0> {
DPR16480::D51     D() : X<a<b>(0) {}
52 
53     static const int a = 0, b = 0;
54   };
55 
56   template<typename T> struct E : X<0> {
EPR16480::E57     E(X<0>) : X<(0)>{} {}
EPR16480::E58     E(X<1>) : X<int{}>{} {}
EPR16480::E59     E(X<2>) : X<(0)>() {}
EPR16480::E60     E(X<3>) : X<int{}>() {}
61   };
62 
63   // FIXME: This should be valid in the union of C99 and C++11.
64   struct F : X<0> {
FPR16480::F65     F() : X<A<T>().n + (T){}.n>{} {} // expected-error +{{}}
66 
67     struct T { int n; };
68     template<typename> struct A { int n; };
69   };
70 
71   // FIXME: This is valid now, but may be made ill-formed by DR1607.
72   struct G : X<0> {
__anon90f2aebd0302PR16480::G73     G() : X<0 && [](){return 0;}()>{} // expected-error +{{}}
74   };
75 
76   struct Errs : X<0> {
ErrsPR16480::Errs77     Errs(X<0>) : decltype X<0>() {} // expected-error {{expected '(' after 'decltype'}}
ErrsPR16480::Errs78     Errs(X<1>) : what is this () {} // expected-error {{expected '(' or '{'}}
79     Errs(X<2>) : decltype(X<0> // expected-note {{to match this '('}}
80   }; // expected-error {{expected ')'}}
81 }
82 
83 template <class U, class V> struct C {
84   int f() { return 4; }
85   class C1 {};
86 };
87 
88 class D {};
89 namespace N {
90 struct E {
91   class F {};
92 };
93 }
94 
95 class G {
96   // These are all valid:
97   void f(int x = C<int, D>().f()) {}
98   void g(int x = C<int, ::D>().f()) {}
99   void h(int x = C<int, N::E>().f()) {}
100   void i(int x = C<int, ::N::E>().f()) {}
101   void j(int x = C<int, decltype(N::E())::F>().f()) {}
102   void k(int x = C<int, C<int, int>>().f()) {}
103   void l(int x = C<int, C<int, int>::C1>().f()) {}
104 
105   // This isn't, but it shouldn't crash. The diagnostics don't matter much.
106   void m(int x = C<int, union int>().f()) {} // expected-error {{declaration of anonymous union must be a definition}} expected-error {{expected a type}}
107 };
108