1 | // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall %s |
2 | |
3 | struct Bitfield { |
4 | int n : 3 = 7; // expected-warning {{C++2a extension}} expected-warning {{changes value from 7 to -1}} |
5 | }; |
6 | |
7 | int a; |
8 | class NoWarning { |
9 | int &n = a; |
10 | public: |
11 | int &GetN() { return n; } |
12 | }; |
13 | |
14 | bool b(); |
15 | int k; |
16 | struct Recurse { // expected-error {{initializer for 'n' needed}} |
17 | int &n = // expected-note {{declared here}} |
18 | b() ? |
19 | Recurse().n : // expected-note {{in evaluation of exception spec}} |
20 | k; |
21 | }; |
22 | |
23 | struct 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 | |
29 | template<int n> struct T { static const int B; }; |
30 | template<> struct T<2> { template<int C, int D> using B = int; }; |
31 | const int C = 0, D = 0; |
32 | struct 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 | |
40 | struct ThrowCtor { ThrowCtor(int) noexcept(false); }; |
41 | struct NoThrowCtor { NoThrowCtor(int) noexcept(true); }; |
42 | |
43 | struct Throw { ThrowCtor tc = 42; }; |
44 | struct NoThrow { NoThrowCtor tc = 42; }; |
45 | |
46 | static_assert(!noexcept(Throw()), "incorrect exception specification"); |
47 | static_assert(noexcept(NoThrow()), "incorrect exception specification"); |
48 | |
49 | struct CheckExcSpec { |
50 | CheckExcSpec() noexcept(true) = default; |
51 | int n = 0; |
52 | }; |
53 | struct 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 | |
58 | struct TypedefInit { |
59 | typedef int A = 0; // expected-error {{illegal initializer}} |
60 | }; |
61 | |
62 | // PR10578 / <rdar://problem/9877267> |
63 | namespace 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 | |
80 | namespace 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()) {} // expected-error {{binds to a temporary object}} |
90 | // expected-error@-1 {{temporary of type 'PR14838::function' has private destructor}} |
91 | const function &r; // expected-note {{reference member declared here}} |
92 | } af; |
93 | } |
94 | |
95 | namespace rdar14084171 { |
96 | struct Point { // expected-note 3 {{candidate constructor}} |
97 | double x; |
98 | double y; |
99 | }; |
100 | struct Sprite { |
101 | Point location = Point(0,0); // expected-error {{no matching constructor for initialization of 'rdar14084171::Point'}} |
102 | }; |
103 | void f(Sprite& x) { x = x; } // expected-warning {{explicitly assigning value of variable}} |
104 | } |
105 | |
106 | namespace PR18560 { |
107 | struct X { int m; }; |
108 | |
109 | template<typename T = X, |
110 | typename U = decltype(T::m)> |
111 | int f(); |
112 | |
113 | struct Y { int b = f(); }; |
114 | } |
115 | |
116 | namespace template_valid { |
117 | // Valid, we shouldn't build a CXXDefaultInitExpr until A's ctor definition. |
118 | struct A { |
119 | A(); |
120 | template <typename T> |
121 | struct B { int m1 = sizeof(A) + sizeof(T); }; |
122 | B<int> m2; |
123 | }; |
124 | A::A() {} |
125 | } |
126 | |
127 | namespace template_default_ctor { |
128 | struct A { |
129 | template <typename T> |
130 | struct B { // expected-error {{initializer for 'm1' needed}} |
131 | int m1 = 0; // expected-note {{declared here}} |
132 | }; |
133 | enum { NOE = noexcept(B<int>()) }; // expected-note {{in evaluation of exception spec}} |
134 | }; |
135 | } |
136 | |
137 | namespace default_ctor { |
138 | struct A { |
139 | struct B { // expected-error {{initializer for 'm1' needed}} |
140 | int m1 = 0; // expected-note {{declared here}} |
141 | }; |
142 | enum { NOE = noexcept(B()) }; // expected-note {{in evaluation of exception spec}} |
143 | }; |
144 | } |
145 | |
146 | namespace member_template { |
147 | struct A { |
148 | template <typename T> |
149 | struct B { |
150 | struct C { // expected-error {{initializer for 'm1' needed}} |
151 | int m1 = 0; // expected-note {{declared here}} |
152 | }; |
153 | template <typename U> |
154 | struct D { // expected-error {{initializer for 'm1' needed}} |
155 | int m1 = 0; // expected-note {{declared here}} |
156 | }; |
157 | }; |
158 | enum { |
159 | NOE1 = noexcept(B<int>::C()), // expected-note {{in evaluation of exception spec}} |
160 | NOE2 = noexcept(B<int>::D<int>()) // expected-note {{in evaluation of exception spec}} |
161 | }; |
162 | }; |
163 | } |
164 | |
165 | namespace explicit_instantiation { |
166 | template<typename T> struct X { |
167 | X(); // expected-note {{in instantiation of default member initializer 'explicit_instantiation::X<float>::n' requested here}} |
168 | int n = T::error; // expected-error {{type 'float' cannot be used prior to '::' because it has no members}} |
169 | }; |
170 | template struct X<int>; // ok |
171 | template<typename T> X<T>::X() {} |
172 | template struct X<float>; // expected-note {{in instantiation of member function 'explicit_instantiation::X<float>::X' requested here}} |
173 | } |
174 | |
175 | namespace local_class { |
176 | template<typename T> void f() { |
177 | struct X { // expected-note {{in instantiation of default member initializer 'local_class::f()::X::n' requested here}} |
178 | int n = T::error; // expected-error {{type 'int' cannot be used prior to '::' because it has no members}} |
179 | }; |
180 | } |
181 | void g() { f<int>(); } // expected-note {{in instantiation of function template specialization 'local_class::f<int>' requested here}} |
182 | } |
183 | |
184 | namespace PR22056 { |
185 | template <int N> |
186 | struct S { |
187 | int x[3] = {[N] = 3}; |
188 | }; |
189 | } |
190 | |
191 | namespace PR28060 { |
192 | template <class T> |
193 | void foo(T v) { |
194 | struct s { |
195 | T *s = 0; |
196 | }; |
197 | } |
198 | template void foo(int); |
199 | } |
200 | |