1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s 2 3 // This must obviously come before the definition of std::initializer_list. 4 void missing_initializerlist() { 5 auto l = {1, 2, 3, 4}; // expected-error {{std::initializer_list was not found}} 6 } 7 8 namespace std { 9 typedef decltype(sizeof(int)) size_t; 10 11 // libc++'s implementation 12 template <class _E> 13 class initializer_list 14 { 15 const _E* __begin_; 16 size_t __size_; 17 18 initializer_list(const _E* __b, size_t __s) 19 : __begin_(__b), 20 __size_(__s) 21 {} 22 23 public: 24 typedef _E value_type; 25 typedef const _E& reference; 26 typedef const _E& const_reference; 27 typedef size_t size_type; 28 29 typedef const _E* iterator; 30 typedef const _E* const_iterator; 31 32 initializer_list() : __begin_(nullptr), __size_(0) {} 33 34 size_t size() const {return __size_;} 35 const _E* begin() const {return __begin_;} 36 const _E* end() const {return __begin_ + __size_;} 37 }; 38 } 39 40 template <typename T, typename U> 41 struct same_type { static const bool value = false; }; 42 template <typename T> 43 struct same_type<T, T> { static const bool value = true; }; 44 45 struct one { char c[1]; }; 46 struct two { char c[2]; }; 47 48 struct A { 49 int a, b; 50 }; 51 52 struct B { 53 B(); 54 B(int, int); 55 }; 56 57 void simple_list() { 58 std::initializer_list<int> il = { 1, 2, 3 }; 59 std::initializer_list<double> dl = { 1.0, 2.0, 3 }; 60 std::initializer_list<A> al = { {1, 2}, {2, 3}, {3, 4} }; 61 std::initializer_list<B> bl = { {1, 2}, {2, 3}, {} }; 62 } 63 64 void function_call() { 65 void f(std::initializer_list<int>); 66 f({1, 2, 3}); 67 68 void g(std::initializer_list<B>); 69 g({ {1, 2}, {2, 3}, {} }); 70 } 71 72 struct C { 73 C(int); 74 }; 75 76 struct D { 77 D(); 78 operator int(); 79 operator C(); 80 }; 81 82 void overloaded_call() { 83 one overloaded(std::initializer_list<int>); 84 two overloaded(std::initializer_list<B>); 85 86 static_assert(sizeof(overloaded({1, 2, 3})) == sizeof(one), "bad overload"); 87 static_assert(sizeof(overloaded({ {1, 2}, {2, 3}, {} })) == sizeof(two), "bad overload"); 88 89 void ambiguous(std::initializer_list<A>); // expected-note {{candidate}} 90 void ambiguous(std::initializer_list<B>); // expected-note {{candidate}} 91 ambiguous({ {1, 2}, {2, 3}, {3, 4} }); // expected-error {{ambiguous}} 92 93 one ov2(std::initializer_list<int>); // expected-note {{candidate}} 94 two ov2(std::initializer_list<C>); // expected-note {{candidate}} 95 // Worst sequence to int is identity, whereas to C it's user-defined. 96 static_assert(sizeof(ov2({1, 2, 3})) == sizeof(one), "bad overload"); 97 // But here, user-defined is worst in both cases. 98 ov2({1, 2, D()}); // expected-error {{ambiguous}} 99 } 100 101 template <typename T> 102 T deduce(std::initializer_list<T>); // expected-note {{conflicting types for parameter 'T' ('int' vs. 'double')}} 103 template <typename T> 104 T deduce_ref(const std::initializer_list<T>&); // expected-note {{conflicting types for parameter 'T' ('int' vs. 'double')}} 105 106 void argument_deduction() { 107 static_assert(same_type<decltype(deduce({1, 2, 3})), int>::value, "bad deduction"); 108 static_assert(same_type<decltype(deduce({1.0, 2.0, 3.0})), double>::value, "bad deduction"); 109 110 deduce({1, 2.0}); // expected-error {{no matching function}} 111 112 static_assert(same_type<decltype(deduce_ref({1, 2, 3})), int>::value, "bad deduction"); 113 static_assert(same_type<decltype(deduce_ref({1.0, 2.0, 3.0})), double>::value, "bad deduction"); 114 115 deduce_ref({1, 2.0}); // expected-error {{no matching function}} 116 } 117 118 void auto_deduction() { 119 auto l = {1, 2, 3, 4}; 120 static_assert(same_type<decltype(l), std::initializer_list<int>>::value, ""); 121 auto bl = {1, 2.0}; // expected-error {{cannot deduce}} 122 123 for (int i : {1, 2, 3, 4}) {} 124 } 125 126 void dangle() { 127 new auto{1, 2, 3}; // expected-error {{cannot use list-initialization}} 128 new std::initializer_list<int>{1, 2, 3}; // expected-warning {{at the end of the full-expression}} 129 } 130 131 struct haslist1 { 132 std::initializer_list<int> il = {1, 2, 3}; // expected-warning{{at the end of the constructor}} 133 haslist1(); 134 }; 135 136 haslist1::haslist1() 137 : il{1, 2, 3} // expected-warning{{at the end of the constructor}} 138 {} 139