1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s 2 3 struct one { char c; }; 4 struct two { char c[2]; }; 5 6 namespace reference { 7 struct A { 8 int i1, i2; 9 }; 10 11 void single_init() { 12 const int &cri1a = {1}; 13 const int &cri1b{1}; 14 15 int i = 1; 16 int &ri1a = {i}; 17 int &ri1b{i}; 18 19 int &ri2 = {1}; // expected-error {{cannot bind to an initializer list temporary}} 20 21 A a{1, 2}; 22 A &ra1a = {a}; 23 A &ra1b{a}; 24 } 25 26 void reference_to_aggregate() { 27 const A &ra1{1, 2}; 28 A &ra2{1, 2}; // expected-error {{cannot bind to an initializer list temporary}} 29 30 const int (&arrayRef)[] = {1, 2, 3}; 31 static_assert(sizeof(arrayRef) == 3 * sizeof(int), "bad array size"); 32 } 33 34 struct B { 35 int i1; 36 }; 37 38 void call() { 39 one f(const int&); 40 f({1}); 41 42 one g(int&); // expected-note {{passing argument}} 43 g({1}); // expected-error {{cannot bind to an initializer list temporary}} 44 int i = 0; 45 g({i}); 46 47 void h(const B&); 48 h({1}); 49 50 void a(B&); // expected-note {{passing argument}} 51 a({1}); // expected-error {{cannot bind to an initializer list temporary}} 52 B b{1}; 53 a({b}); 54 } 55 56 void overloading() { 57 one f(const int&); 58 two f(const B&); 59 60 // First is identity conversion, second is user-defined conversion. 61 static_assert(sizeof(f({1})) == sizeof(one), "bad overload resolution"); 62 63 one g(int&); 64 two g(const B&); 65 66 static_assert(sizeof(g({1})) == sizeof(two), "bad overload resolution"); 67 68 one h(const int&); 69 two h(const A&); 70 71 static_assert(sizeof(h({1, 2})) == sizeof(two), "bad overload resolution"); 72 } 73 74 void edge_cases() { 75 // FIXME: very poor error message 76 int const &b({0}); // expected-error {{could not bind}} 77 } 78 79 } 80 81 namespace PR12182 { 82 void f(int const(&)[3]); 83 84 void g() { 85 f({1, 2}); 86 } 87 } 88 89 namespace PR12660 { 90 const int &i { 1 }; 91 struct S { S(int); } const &s { 2 }; 92 } 93 94 namespace b7891773 { 95 typedef void (*ptr)(); 96 template <class T> void f(); 97 int g(const ptr &); 98 int k = g({ f<int> }); 99 } 100 101 namespace inner_init { 102 struct A { int n; }; 103 struct B { A &&r; }; 104 B b1 { 0 }; // expected-error {{reference to type 'inner_init::A' could not bind to an rvalue of type 'int'}} 105 B b2 { { 0 } }; 106 B b3 { { { 0 } } }; // expected-warning {{braces around scalar init}} 107 108 struct C { C(int); }; // expected-note 2{{candidate constructor (the implicit}} \ 109 // expected-note {{candidate constructor not viable: cannot convert initializer list argument to 'int'}} 110 struct D { C &&r; }; 111 D d1 { 0 }; // ok, 0 implicitly converts to C 112 D d2 { { 0 } }; // ok, { 0 } calls C(0) 113 D d3 { { { 0 } } }; // ok, { { 0 } } calls C({ 0 }), expected-warning {{braces around scalar init}} 114 D d4 { { { { 0 } } } }; // expected-error {{no matching constructor for initialization of 'inner_init::C &&'}} 115 116 struct E { explicit E(int); }; // expected-note 2{{here}} 117 struct F { E &&r; }; 118 F f1 { 0 }; // expected-error {{could not bind to an rvalue of type 'int'}} 119 F f2 { { 0 } }; // expected-error {{chosen constructor is explicit}} 120 F f3 { { { 0 } } }; // expected-error {{chosen constructor is explicit}} 121 } 122 123 namespace PR20844 { 124 struct A {}; 125 struct B { operator A&(); } b; 126 A &a{b}; // expected-error {{excess elements}} expected-note {{in initialization of temporary of type 'PR20844::A'}} 127 } 128 129 namespace PR21834 { 130 const int &a = (const int &){0}; // expected-error {{cannot bind to an initializer list}} 131 } 132
