153 lines · cpp
1// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -pedantic-errors2 3struct one { char c[1]; };4struct two { char c[2]; };5 6namespace std {7 typedef decltype(sizeof(int)) size_t;8 9 // libc++'s implementation10 template <class _E>11 class initializer_list12 {13 const _E* __begin_;14 size_t __size_;15 16 initializer_list(const _E* __b, size_t __s)17 : __begin_(__b),18 __size_(__s)19 {}20 21 public:22 typedef _E value_type;23 typedef const _E& reference;24 typedef const _E& const_reference;25 typedef size_t size_type;26 27 typedef const _E* iterator;28 typedef const _E* const_iterator;29 30 initializer_list() : __begin_(nullptr), __size_(0) {}31 32 size_t size() const {return __size_;}33 const _E* begin() const {return __begin_;}34 const _E* end() const {return __begin_ + __size_;}35 };36}37 38namespace integral {39 40 void initialization() {41 { const int a{}; static_assert(a == 0, ""); }42 { const int a = {}; static_assert(a == 0, ""); }43 { const int a{1}; static_assert(a == 1, ""); }44 { const int a = {1}; static_assert(a == 1, ""); }45 { const int a{1, 2}; } // expected-error {{excess elements}}46 { const int a = {1, 2}; } // expected-error {{excess elements}}47 // FIXME: Redundant warnings.48 { const short a{100000}; } // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast}} expected-warning {{changes value}}49 { const short a = {100000}; } // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast}} expected-warning {{changes value}}50 { if (const int a{1}) static_assert(a == 1, ""); }51 { if (const int a = {1}) static_assert(a == 1, ""); }52 }53 54 int direct_usage() {55 int ar[10];56 (void) ar[{1}]; // expected-error {{array subscript is not an integer}}57 58 return {1}; // expected-warning {{braces around scalar init}}59 }60 61 void inline_init() {62 auto v = int{1};63 (void) new int{1};64 }65 66 struct A {67 int i;68 A() : i{1} {}69 };70 71 void function_call() {72 void takes_int(int);73 takes_int({1}); // expected-warning {{braces around scalar init}}74 }75 76 void overloaded_call() {77 one overloaded(int);78 two overloaded(double);79 80 static_assert(sizeof(overloaded({0})) == sizeof(one), "bad overload"); // expected-warning {{braces around scalar init}}81 static_assert(sizeof(overloaded({0.0})) == sizeof(two), "bad overload"); // expected-warning {{braces around scalar init}}82 83 void ambiguous(int, double); // expected-note {{candidate}}84 void ambiguous(double, int); // expected-note {{candidate}}85 ambiguous({0}, {0}); // expected-error {{ambiguous}}86 87 void emptylist(int);88 void emptylist(int, int, int);89 emptylist({});90 emptylist({}, {}, {});91 }92 93 void edge_cases() {94 int a({0}); // expected-error {{cannot initialize non-class type 'int' with a parenthesized initializer list}}95 (void) int({0}); // expected-error {{cannot initialize non-class type 'int' with a parenthesized initializer list}}96 new int({0}); // expected-error {{cannot initialize non-class type 'int' with a parenthesized initializer list}}97 98 int *b({0}); // expected-error {{cannot initialize non-class type 'int *' with a parenthesized initializer list}}99 typedef int *intptr;100 int *c = intptr({0}); // expected-error {{cannot initialize non-class type 'intptr' (aka 'int *') with a parenthesized initializer list}}101 }102 103 template<typename T> void dependent_edge_cases() {104 T a({0});105 (void) T({0});106 new T({0});107 108 T *b({0});109 typedef T *tptr;110 T *c = tptr({0});111 }112 113 void default_argument(int i = {}) {114 }115 struct DefaultArgument {116 void default_argument(int i = {}) {117 }118 };119}120 121namespace PR12118 {122 void test() {123 one f(std::initializer_list<int>); 124 two f(int); 125 126 // to initializer_list is preferred127 static_assert(sizeof(f({0})) == sizeof(one), "bad overload");128 }129}130 131namespace excess_braces_sfinae {132 using valid = int&;133 using invalid = float&;134 135 template<typename T> valid braces1(decltype(T{0})*);136 template<typename T> invalid braces1(...);137 138 template<typename T> valid braces2(decltype(T{{0}})*);139 template<typename T> invalid braces2(...);140 141 template<typename T> valid braces3(decltype(T{{{0}}})*);142 template<typename T> invalid braces3(...);143 144 valid a = braces1<int>(0);145 invalid b = braces2<int>(0);146 invalid c = braces3<int>(0);147 148 struct X { int n; };149 valid d = braces1<X>(0);150 valid e = braces2<X>(0);151 invalid f = braces3<X>(0);152}153