1// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall %s
2
3struct Bitfield {
4  int n : 3 = 7; // expected-error {{bitfield member cannot have an in-class initializer}}
5};
6
7int a;
8class NoWarning {
9  int &n = a;
10public:
11  int &GetN() { return n; }
12};
13
14bool b();
15int k;
16struct Recurse {
17  int &n = // expected-error {{cannot use defaulted default constructor of 'Recurse' within the class outside of member functions because 'n' has an initializer}}
18      b() ?
19      Recurse().n : // expected-note {{implicit default constructor for 'Recurse' first required here}}
20      k;
21};
22
23struct UnknownBound {
24  int as[] = { 1, 2, 3 }; // expected-error {{array bound cannot be deduced from an in-class initializer}}
25  int bs[4] = { 4, 5, 6, 7 };
26  int cs[] = { 8, 9, 10 }; // expected-error {{array bound cannot be deduced from an in-class initializer}}
27};
28
29template<int n> struct T { static const int B; };
30template<> struct T<2> { template<int C, int D> using B = int; };
31const int C = 0, D = 0;
32struct S {
33  int as[] = { decltype(x)::B<C, D>(0) }; // expected-error {{array bound cannot be deduced from an in-class initializer}}
34  T<sizeof(as) / sizeof(int)> x;
35  // test that we handle invalid array bound deductions without crashing when the declarator name is itself invalid
36  operator int[](){}; // expected-error {{'operator int' cannot be the name of a variable or data member}} \
37                      // expected-error {{array bound cannot be deduced from an in-class initializer}}
38};
39
40struct ThrowCtor { ThrowCtor(int) noexcept(false); };
41struct NoThrowCtor { NoThrowCtor(int) noexcept(true); };
42
43struct Throw { ThrowCtor tc = 42; };
44struct NoThrow { NoThrowCtor tc = 42; };
45
46static_assert(!noexcept(Throw()), "incorrect exception specification");
47static_assert(noexcept(NoThrow()), "incorrect exception specification");
48
49struct CheckExcSpec {
50  CheckExcSpec() noexcept(true) = default;
51  int n = 0;
52};
53struct CheckExcSpecFail {
54  CheckExcSpecFail() noexcept(true) = default; // expected-error {{exception specification of explicitly defaulted default constructor does not match the calculated one}}
55  ThrowCtor tc = 123;
56};
57
58struct TypedefInit {
59  typedef int A = 0; // expected-error {{illegal initializer}}
60};
61
62// PR10578 / <rdar://problem/9877267>
63namespace PR10578 {
64  template<typename T>
65  struct X {
66    X() {
67      T* x = 1; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
68    }
69  };
70
71  struct Y : X<int> {
72    Y();
73  };
74
75  Y::Y() try { // expected-note{{in instantiation of member function 'PR10578::X<int>::X' requested here}}
76  } catch(...) {
77  }
78}
79
80namespace PR14838 {
81  struct base { ~base() {} };
82  class function : base {
83    ~function() {} // expected-note {{implicitly declared private here}}
84  public:
85    function(...) {}
86  };
87  struct thing {};
88  struct another {
89    another() : r(thing()) {}
90    // expected-error@-1 {{temporary of type 'const PR14838::function' has private destructor}}
91    // expected-warning@-2 {{binding reference member 'r' to a temporary value}}
92    const function &r; // expected-note {{reference member declared here}}
93  } af;
94}
95
96namespace rdar14084171 {
97  struct Point { // expected-note 3 {{candidate constructor}}
98    double x;
99    double y;
100  };
101  struct Sprite {
102    Point location = Point(0,0); // expected-error {{no matching constructor for initialization of 'rdar14084171::Point'}}
103  };
104  void f(Sprite& x) { x = x; }
105}
106
107namespace PR18560 {
108  struct X { int m; };
109
110  template<typename T = X,
111           typename U = decltype(T::m)>
112  int f();
113
114  struct Y { int b = f(); };
115}
116
117namespace template_valid {
118// Valid, we shouldn't build a CXXDefaultInitExpr until A's ctor definition.
119struct A {
120  A();
121  template <typename T>
122  struct B { int m1 = sizeof(A) + sizeof(T); };
123  B<int> m2;
124};
125A::A() {}
126}
127
128namespace template_default_ctor {
129struct A {
130  template <typename T>
131  struct B {
132    int m1 = 0; // expected-error {{cannot use defaulted default constructor of 'B' within 'A' outside of member functions because 'm1' has an initializer}}
133  };
134  // expected-note@+1 {{implicit default constructor for 'template_default_ctor::A::B<int>' first required here}}
135  enum { NOE = noexcept(B<int>()) };
136};
137}
138
139namespace default_ctor {
140struct A {
141  struct B {
142    int m1 = 0; // expected-error {{cannot use defaulted default constructor of 'B' within 'A' outside of member functions because 'm1' has an initializer}}
143  };
144  // expected-note@+1 {{implicit default constructor for 'default_ctor::A::B' first required here}}
145  enum { NOE = noexcept(B()) };
146};
147}
148
149namespace member_template {
150struct A {
151  template <typename T>
152  struct B {
153    struct C {
154      int m1 = 0; // expected-error {{cannot use defaulted default constructor of 'C' within 'A' outside of member functions because 'm1' has an initializer}}
155    };
156    template <typename U>
157    struct D {
158      int m1 = 0; // expected-error {{cannot use defaulted default constructor of 'D' within 'A' outside of member functions because 'm1' has an initializer}}
159    };
160  };
161  enum {
162    // expected-note@+1 {{implicit default constructor for 'member_template::A::B<int>::C' first required here}}
163    NOE1 = noexcept(B<int>::C()),
164    // expected-note@+1 {{implicit default constructor for 'member_template::A::B<int>::D<int>' first required here}}
165    NOE2 = noexcept(B<int>::D<int>())
166  };
167};
168}
169
170namespace explicit_instantiation {
171template<typename T> struct X {
172  X(); // expected-note {{in instantiation of default member initializer 'explicit_instantiation::X<float>::n' requested here}}
173  int n = T::error; // expected-error {{type 'float' cannot be used prior to '::' because it has no members}}
174};
175template struct X<int>; // ok
176template<typename T> X<T>::X() {}
177template struct X<float>; // expected-note {{in instantiation of member function 'explicit_instantiation::X<float>::X' requested here}}
178}
179
180namespace local_class {
181template<typename T> void f() {
182  struct X { // expected-note {{in instantiation of default member initializer 'local_class::f()::X::n' requested here}}
183    int n = T::error; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
184  };
185}
186void g() { f<int>(); } // expected-note {{in instantiation of function template specialization 'local_class::f<int>' requested here}}
187}
188
189namespace PR22056 {
190template <int N>
191struct S {
192  int x[3] = {[N] = 3};
193};
194}
195
196namespace PR28060 {
197template <class T>
198void foo(T v) {
199  struct s {
200    T *s = 0;
201  };
202}
203template void foo(int);
204}
205