Clang Project

clang_source_code/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp
1// RUN: %clang_cc1 -fsyntax-only -std=c++11 -triple x86_64-apple-macosx10.6.7 -verify %s
2
3// Verify that narrowing conversions in initializer lists cause errors in C++0x
4// mode.
5
6void std_example() {
7  int x = 999;  // x is not a constant expression
8  const int y = 999;
9  const int z = 99;
10  char c1 = x;  // OK, though it might narrow (in this case, it does narrow)
11  char c2{x};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
12  char c3{y};  // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}
13  char c4{z};  // OK: no narrowing needed
14  unsigned char uc1 = {5};  // OK: no narrowing needed
15  unsigned char uc2 = {-1};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
16  unsigned int ui1 = {-1};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
17  signed int si1 =
18    { (unsigned int)-1 };  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
19  int ii = {2.0};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
20  float f1 { x };  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
21  float f2 { 7 };  // OK: 7 can be exactly represented as a float
22  int f(int);
23  int a[] =
24    { 2, f(2), f(2.0) };  // OK: the double-to-int conversion is not at the top level
25}
26
27enum UnscopedEnum {
28  EnumVal = 300
29};
30
31// Test each rule individually.
32
33template<typename T>
34struct Agg {
35  T t;
36};
37
38template<typename T>
39struct Convert {
40  constexpr Convert(T v) : v(v) {}
41  constexpr operator T() const { return v; }
42  T v;
43};
44template<typename T> Convert<T> ConvertVar();
45
46// C++0x [dcl.init.list]p7: A narrowing conversion is an implicit conversion
47//
48// * from a floating-point type to an integer type, or
49
50void float_to_int() {
51  Agg<char> a1 = {1.0F};  // expected-error {{type 'float' cannot be narrowed to 'char'}} expected-note {{silence}}
52  Agg<char> a2 = {1.0};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
53  Agg<char> a3 = {1.0L};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
54
55  float f = 1.0;
56  double d = 1.0;
57  long double ld = 1.0;
58  Agg<char> a4 = {f};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
59  Agg<char> a5 = {d};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
60  Agg<char> a6 = {ld};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
61
62  Agg<char> ce1 = { Convert<float>(1.0) }; // expected-error {{type 'float' cannot be narrowed to 'char'}} expected-note {{silence}}
63  Agg<char> ce2 = { ConvertVar<double>() }; // expected-error {{type 'double' cannot be narrowed to 'char'}} expected-note {{silence}}
64
65  bool b{1.0}; // expected-error {{type 'double' cannot be narrowed to 'bool'}} expected-note {{silence}}
66  Agg<bool> ab = {0.0}; // expected-error {{type 'double' cannot be narrowed to 'bool'}} expected-note {{silence}}
67}
68
69// * from long double to double or float, or from double to float, except where
70//   the source is a constant expression and the actual value after conversion
71//   is within the range of values that can be represented (even if it cannot be
72//   represented exactly), or
73
74void shrink_float() {
75  // These aren't constant expressions.
76  float f = 1.0;
77  double d = 1.0;
78  long double ld = 1.0;
79
80  // Variables.
81  Agg<float> f1 = {f};  // OK  (no-op)
82  Agg<float> f2 = {d};  // expected-error {{non-constant-expression cannot be narrowed from type 'double' to 'float'}} expected-note {{silence}}
83  Agg<float> f3 = {ld};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
84  // Exact constants.
85  Agg<float> f4 = {1.0};  // OK  (double constant represented exactly)
86  Agg<float> f5 = {1.0L};  // OK  (long double constant represented exactly)
87  // Inexact but in-range constants.
88  Agg<float> f6 = {0.1};  // OK (double constant in range but rounded)
89  Agg<float> f7 = {0.1L};  // OK (long double constant in range but rounded)
90  // Out of range constants.
91  Agg<float> f8 = {1E50};  // expected-error {{constant expression evaluates to 1.000000e+50 which cannot be narrowed to type 'float'}} expected-note {{silence}}
92  Agg<float> f9 = {1E50L};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
93  // More complex constant expression.
94  constexpr long double e40 = 1E40L, e30 = 1E30L, e39 = 1E39L;
95  Agg<float> f10 = {e40 - 5 * e39 + e30 - 5 * e39};  // OK
96
97  // Variables.
98  Agg<double> d1 = {f};  // OK  (widening)
99  Agg<double> d2 = {d};  // OK  (no-op)
100  Agg<double> d3 = {ld};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
101  // Exact constant.
102  Agg<double> d4 = {1.0L};  // OK  (long double constant represented exactly)
103  // Inexact but in-range constant.
104  Agg<double> d5 = {0.1L};  // OK (long double constant in range but rounded)
105  // Out of range constant.
106  Agg<double> d6 = {1E315L};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
107  // More complex constant expression.
108  constexpr long double e315 = 1E315L, e305 = 1E305L, e314 = 1E314L;
109  Agg<double> d7 = {e315 - 5 * e314 + e305 - 5 * e314};  // OK
110
111  Agg<float> ce1 = { Convert<double>(1e300) }; // expected-error {{constant expression evaluates to 1.000000e+300 which cannot be narrowed to type 'float'}} expected-note {{silence}}
112  Agg<double> ce2 = { ConvertVar<long double>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'long double' to 'double'}} expected-note {{silence}}
113}
114
115// * from an integer type or unscoped enumeration type to a floating-point type,
116//   except where the source is a constant expression and the actual value after
117//   conversion will fit into the target type and will produce the original
118//   value when converted back to the original type, or
119void int_to_float() {
120  // Not a constant expression.
121  char c = 1;
122  UnscopedEnum e = EnumVal;
123
124  // Variables.  Yes, even though all char's will fit into any floating type.
125  Agg<float> f1 = {c};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
126  Agg<double> f2 = {c};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
127  Agg<long double> f3 = {c};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
128
129  Agg<float> f4 = {e};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
130  Agg<double> f5 = {e};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
131  Agg<long double> f6 = {e};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
132
133  // Constants.
134  Agg<float> f7 = {12345678};  // OK (exactly fits in a float)
135  Agg<float> f8 = {EnumVal};  // OK
136  Agg<float> f9 = {123456789};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
137
138  Agg<float> ce1 = { Convert<int>(123456789) }; // expected-error {{constant expression evaluates to 123456789 which cannot be narrowed to type 'float'}} expected-note {{silence}}
139  Agg<double> ce2 = { ConvertVar<long long>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'long long' to 'double'}} expected-note {{silence}}
140}
141
142// * from an integer type or unscoped enumeration type to an integer type that
143//   cannot represent all the values of the original type, except where the
144//   source is a constant expression and the actual value after conversion will
145//   fit into the target type and will produce the original value when converted
146//   back to the original type.
147void shrink_int() {
148  // Not a constant expression.
149  short s = 1;
150  UnscopedEnum e = EnumVal;
151  unsigned short us = 1;
152  Agg<char> c1 = {s};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
153  Agg<char> c2 = {e};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
154  Agg<unsigned short> s1 = {s};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
155  Agg<short> s2 = {us};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
156
157  // "that cannot represent all the values of the original type" means that the
158  // validity of the program depends on the relative sizes of integral types.
159  // This test compiles with -m64, so sizeof(int)<sizeof(long)==sizeof(long
160  // long).
161  long l1 = 1;
162  Agg<int> i1 = {l1};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
163  Agg<int> i2 = {e};  // OK
164  long long ll = 1;
165  Agg<long> l2 = {ll};  // OK
166
167  // Constants.
168  Agg<char> c3 = {127};  // OK
169  Agg<char> c4 = {300};  // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}
170  Agg<char> c5 = {EnumVal};  // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}
171
172  Agg<int> i3 = {0x7FFFFFFFU};  // OK
173  Agg<int> i4 = {EnumVal};  // OK
174  Agg<int> i5 = {0x80000000U};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
175  Agg<unsigned int> i6 = {-0x80000000L};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
176
177  // Bool is also an integer type, but conversions to it are a different AST
178  // node.
179  Agg<bool> b1 = {0};  // OK
180  Agg<bool> b2 = {1};  // OK
181  Agg<bool> b3 = {-1};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
182
183  // Conversions from pointers to booleans aren't narrowing conversions.
184  Agg<bool>* ptr = &b1;
185  Agg<bool> b = {ptr};  // OK
186
187  Agg<short> ce1 = { Convert<int>(100000) }; // expected-error {{constant expression evaluates to 100000 which cannot be narrowed to type 'short'}} expected-note {{silence}} expected-warning {{changes value from 100000 to -31072}}
188  Agg<char> ce2 = { ConvertVar<short>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'short' to 'char'}} expected-note {{silence}}
189
190  // Negative -> larger unsigned type.
191  unsigned long long ll1 = { -1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}}
192  unsigned long long ll2 = { 1 }; // OK
193  unsigned long long ll3 = { s }; // expected-error {{cannot be narrowed from type 'short'}} expected-note {{silence}}
194  unsigned long long ll4 = { us }; // OK
195  unsigned long long ll5 = { ll }; // expected-error {{cannot be narrowed from type 'long long'}} expected-note {{silence}}
196  Agg<unsigned long long> ll6 = { -1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}}
197  Agg<unsigned long long> ll7 = { 18446744073709551615ULL }; // OK
198  Agg<unsigned long long> ll8 = { __int128(18446744073709551615ULL) + 1 }; // expected-error {{ 18446744073709551616 which cannot be narrowed}} expected-note {{silence}} expected-warning {{changes value}}
199  signed char c = 'x';
200  unsigned short usc1 = { c }; // expected-error {{non-constant-expression cannot be narrowed from type 'signed char'}} expected-note {{silence}}
201  unsigned short usc2 = { (signed char)'x' }; // OK
202  unsigned short usc3 = { (signed char)-1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}}
203}
204
205// Be sure that type- and value-dependent expressions in templates get the error
206// too.
207
208template<int I, typename T>
209void maybe_shrink_int(T t) {
210  Agg<short> s1 = {t};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
211  Agg<short> s2 = {I};  // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}
212  Agg<T> t2 = {700};  // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}
213}
214
215void test_template() {
216  maybe_shrink_int<15>((int)3);  // expected-note {{in instantiation}}
217  maybe_shrink_int<70000>((char)3);  // expected-note {{in instantiation}}
218}
219
220
221// We don't want qualifiers on the types in the diagnostic.
222
223void test_qualifiers(int i) {
224  const int j = i;
225  struct {const unsigned char c;} c1 = {j};  // expected-error {{from type 'int' to 'unsigned char' in}} expected-note {{silence}}
226  // Template arguments make it harder to avoid printing qualifiers:
227  Agg<const unsigned char> c2 = {j};  // expected-error {{from type 'int' to 'const unsigned char' in}} expected-note {{silence}}
228}
229
230// Test SFINAE checks.
231template<unsigned> struct Value { };
232
233template<typename T>
234int &check_narrowed(Value<sizeof((T){1.1})>);
235
236template<typename T>
237float &check_narrowed(...);
238
239void test_narrowed(Value<sizeof(int)> vi, Value<sizeof(double)> vd) {
240  int &ir = check_narrowed<double>(vd);
241  float &fr = check_narrowed<int>(vi);
242}
243
CodeThinker, Enjoy your reading code